void DirectionalSlump(Hit hit)
{
gameObject.SetActive(true);
//randomly choose an disintegration type
switch (Rand.Range(1, 2))
{
case 0:
disintegration = Type.Slump;
break;
case 1:
case 2:
disintegration = Type.Directional_Slump;
break;
default:
Assert.IsTrue(false, "** Default Case Reached **");
break;
}
//cycle through pieces and send them flying
foreach (Transform child in transform)
{
int direction;
//activate physics on this piece
Rigidbody2D childRigidbody2D = child.GetComponent <Rigidbody2D>();
childRigidbody2D.isKinematic = false;
//start countdown towards this piece fading out
BreakablePiece piece = child.GetComponent <BreakablePiece>();
piece.CountDown();
//apply disintegrations!
switch (disintegration)
{
case Type.Slump:
childRigidbody2D.AddExplosionForce(250, transform.position, 3);
break;
case Type.Directional_Slump:
direction = (hit.horizontalSide == Side.Right) ? 1 : -1;
childRigidbody2D.AddForce(new Vector3(0, -100, 0));
childRigidbody2D.AddExplosionForce(2000, new Vector3(
transform.position.x + direction,
transform.position.y + .5f,
transform.position.z), 2
);
break;
default:
Assert.IsTrue(false, "** Default Case Reached **");
break;
}
}
}
private void Explode()
{
Collider2D[] collider2Ds = Physics2D.OverlapCircleAll(transform.position, _radius);
foreach (Collider2D nearbyObject in collider2Ds)
{
if (nearbyObject.tag == "Enemy")
{
IMoveVelocity moveVelocity = nearbyObject.GetComponent <IMoveVelocity>();
if (moveVelocity != null)
{
moveVelocity.DisableMovement(0.5f);
}
Rigidbody2D rb2D = nearbyObject.GetComponent <Rigidbody2D>();
if (rb2D != null)
{
rb2D.AddExplosionForce(_force, transform.position, _radius);
}
IDamageable damageable = nearbyObject.GetComponent <IDamageable>();
if (damageable != null)
{
damageable.Damage(_damage, true);
}
}
Bullet bullet = nearbyObject.GetComponent <Bullet>();
if (bullet != null)
{
ObjectPool.Instance.ReleaseGameObject(bullet.gameObject);
}
}
}
void CmdExplode()
{
Instantiate(ExplosionEffect, transform.position, transform.rotation);
ExplosinonColliders = Physics2D.OverlapCircleAll(transform.position, radius);
foreach (Collider2D col in ExplosinonColliders)
{
Rigidbody2D rb = col.GetComponentInParent <Rigidbody2D>();
if (rb != null)
{
for (int i = 0; i < 100; i++)
{
rb.AddExplosionForce(explosionForce, transform.position, radius);
}
Debug.Log("Explodes");
if (col.gameObject.tag == "Player")
{
//GameObject hit = ;
PlayerHealth pH = col.gameObject.GetComponent <PlayerHealth>();
Debug.Log("GrenadeHits");
pH.TakeDamage(70);
}
//rb.AddForce(new Vector3 (100,100,0)-transform.position);
Debug.Log("ForceADded");
}
}
Destroy(gameObject);
}
private void Explode()
{
Vector3 startPosition = transform.position;
Collider2D[] colliders = Physics2D.OverlapCircleAll(new Vector2(transform.position.x, transform.position.y), 1f);
explosion.SetActive(true);
explosion.GetComponent <Animator>().SetTrigger("Explode");
AudioManager.instance.PlaySFX(AudioManager.AudioSFX.Explode);
foreach (Collider2D hit in colliders)
{
Rigidbody2D rbToTest = hit.GetComponent <Rigidbody2D>();
if (rbToTest == null)
{
rbToTest = hit.transform.parent.GetComponent <Rigidbody2D>();
}
if (rbToTest && hit.gameObject.tag == "Treasure")
{
if (!rbToTest.transform.GetComponent <Treasure>().explodingAlready)
{
rbToTest.AddExplosionForce(500f, startPosition, 20f);
GameManager.instance.treasureGenerator.ExplodeTreasure(rbToTest.transform.GetComponent <Treasure>(), 2, transform.position);
}
}
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
Debug.Log(collision.gameObject.name);
Instantiate(explosionPrefab, transform.position, Quaternion.identity);
Collider2D[] collidersHit = Physics2D.OverlapCircleAll(transform.position, explosionRadius);
Debug.Log(collision.gameObject.name);
foreach (Collider2D collider in collidersHit)
{
Rigidbody2D targetBody = collider.GetComponent <Rigidbody2D>();
// Debug.Log(targetBody.name);
if (targetBody == null)
{
continue;
}
targetBody.AddExplosionForce(explosionForce, transform.position, explosionRadius);
Health targetHealth = collider.GetComponent <Health>();
if (targetHealth == null)
{
continue;
}
targetHealth.TakeDamage();
}
Destroy(gameObject);
}
void Explode()
{
//show explosion
Instantiate(explosionEffect, transform.position, transform.rotation);
//find objects
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, blastRadius, Mask);
foreach (Collider2D nearbyObject in colliders)
{
Rigidbody2D rb = nearbyObject.GetComponent <Rigidbody2D>();
if (rb != null)
{
rb.AddExplosionForce(explosionForce, transform.position, blastRadius);
nearbyObject.transform.SendMessage("TakeDamage", damage, SendMessageOptions.DontRequireReceiver);
}
}
//remove grenade
Destroy(gameObject);
//the Explosion
}
private void Explode()
{
foreach (GameObject gameObject in _gameObjects)
{
Rigidbody2D rigidbody2D = gameObject.GetComponent <Rigidbody2D>();
rigidbody2D.AddExplosionForce(gameObject.transform.position - transform.position, magnitude, radius);
}
}
public void Collision(ProjectileCollision collider)
{
Vector2 velocity = collider.rb.velocity;
Vector2 position = new Vector2(collider.transform.position.x, collider.transform.position.y);
rb.AddExplosionForce(collider.ExplosionForce, position);
TakeDamage(collider.CalculateDamage(velocity));
}
private void Explode()
{
foreach (Transform child in transform.GetAllChildren())
{
Rigidbody2D rigidbody2D = child.GetComponent <Rigidbody2D>();
rigidbody2D.AddExplosionForce(child.transform.position - transform.position, magnitude, radius);
}
}
private void AddExplosionForce(Rigidbody2D rb)
{
var explosion_dir = rb.position - (Vector2)transform.position;
var explosion_dist = explosion_dir.magnitude;
explosion_dir /= explosion_dist;
rb.AddExplosionForce(m_explosion_force, transform.position, m_explosion_radius);
}
public void bang(float s)
{
float f = s * s * forceMulti;
//Handheld.Vibrate();
for (int i = 0; i <= s * s * slimeMulti; i++)
{
Vector3 offset = Random.insideUnitSphere * size * s;
Rigidbody2D r2d = Instantiate(bangObject, transform.position + offset, Quaternion.identity).GetComponent <Rigidbody2D>();
r2d.AddExplosionForce(f, transform.position, f);
}
Destroy(gameObject);
}
public static void Explode(this GameObject source, float explosionForce, Vector3 explosionPosition, float explosionRadius)
{
Collider2D[] colliders = Physics2D.OverlapCircleAll(source.transform.position, explosionRadius);
foreach (Collider2D col in colliders)
{
Rigidbody2D rb = col.gameObject.GetComponent <Rigidbody2D> ();
if (rb != null)
{
rb.AddExplosionForce(explosionForce, source.transform.position, explosionRadius);
}
}
}
void Explode()
{
Vector2 explosionPos = transform.position;
Collider2D[] colliders = Physics2D.OverlapCircleAll(explosionPos, radius);
foreach (Collider2D hit in colliders)
{
Rigidbody2D rigidbody = hit.GetComponent <Rigidbody2D>();
if (rigidbody != null)
{
rigidbody.AddExplosionForce(power, explosionPos, radius);
}
}
}
private void Boom()
{
Collider2D[] List = Physics2D.OverlapCircleAll(transform.position, 2f);
foreach (Collider2D hit in List)
{
Rigidbody2D rigid = hit.gameObject.GetComponent <Rigidbody2D>();
if (rigid != null)
{
Debug.Log("BOOM RUNNING");
rigid.AddExplosionForce(100f, this.transform.position, 5f, 10f);
//Rigidbody2DExtension.AddExplosionForce(rigid, 2f, transform.position, 2f);
}
}
}
void OnTriggerEnter2D(Collider2D other)
{
if (timer <= 0)
{
return;
}
if ((mask & 1 << other.gameObject.layer) == 1 << other.gameObject.layer) //Test it against our collision layer mask
{
other.gameObject.SendMessage("Explode", SendMessageOptions.DontRequireReceiver);
Rigidbody2D rb = other.gameObject.GetComponent <Rigidbody2D>();
if (rb)
{
rb.AddExplosionForce(20f, gameObject.transform.position, gameObject.GetComponent <CircleCollider2D>().radius, 5);
}
}
}
void Explode()
{
StartCoroutine(cameraShake.Shake(.2f, .4f));
Instantiate(explosionEffect, transform.position, transform.rotation);
//Get nearby objects
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, radius);
foreach (Collider2D nearbyObject in colliders)
{
Rigidbody2D rb = nearbyObject.GetComponent <Rigidbody2D>();
if (rb != null)
{
rb.AddExplosionForce(force, transform.position, radius);
}
}
StartCoroutine(RemoveGrenade());
}
public virtual void Explode()
{
//If Instant detonation, apply force to objects within the radius
if (aoeType == EffectType.Instant)
{
Ray ray = viewCamera.ScreenPointToRay(Input.mousePosition);
Plane groundPlane = new Plane(Vector3.back, Vector3.zero);
float rayDistance;
if (groundPlane.Raycast(ray, out rayDistance))
{
Vector2 point = ray.GetPoint(rayDistance);
transform.position = point;
Instantiate(explosionAnimation, transform.position, transform.rotation);
//Get nearby enemies
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, radius);
foreach (Collider2D nearbyObj in colliders)
{
if (nearbyObj.gameObject.gameObject.layer == LayerMask.NameToLayer("Enemies"))
{
var swarmMember = nearbyObj.gameObject.GetComponent <SwarmMember>();
if (swarmMember != null)
{
swarmMember.HitByAbility(stunFrames);
}
Rigidbody2D rb = nearbyObj.GetComponent <Rigidbody2D>();
if (rb != null)
{
rb.AddExplosionForce(force, transform.position, radius);
}
}
}
}
}
//Else simply instantiate the explosion and let it apply the force from within that gameobject
else
{
Instantiate(explosionAnimation, transform.position, transform.rotation);
}
Destroy(gameObject);
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (isExplosion)
{
return;
}
isExplosion = true;
foreach (Collider2D collider in
Physics2D.OverlapCircleAll(transform.position, radius))
{
Rigidbody2D other = collider.gameObject.GetComponent <Rigidbody2D>();
if (other == null || transform.position == null)
{
continue;
}
other.AddExplosionForce(strongth, transform.position, radius);
other.gameObject.GetComponent <EnduranceBody>()?.Impact(destruction);
}
}
private void Start()
{
Vector3 explosionPos = transform.position;
Collider2D[] colliders = Physics2D.OverlapCircleAll(explosionPos, radius);
Collider2D[] damageColliders = Physics2D.OverlapCircleAll(explosionPos, radius / 2);
foreach (Collider2D col in colliders)
{
Rigidbody2D rb2D = col.GetComponent <Rigidbody2D>();
if (rb2D)
{
rb2D.AddExplosionForce(power, explosionPos, radius);
}
}
foreach (Collider2D col in damageColliders)
{
Wood_HP woodHP = col.GetComponent <Wood_HP>();
Stone_HP stoneHP = col.GetComponent <Stone_HP>();
EnemyHealth enemyHP = col.GetComponent <EnemyHealth>();
if (woodHP)
{
woodHP.state += 3;
}
if (stoneHP)
{
stoneHP.state += 3;
}
if (enemyHP)
{
enemyHP.state += 2;
}
}
}
void Explode()
{
// TODO: destroy objects around you
// TODO: add sound effect to Big & Small Explosion prefabs
Vector3 explosionPos = transform.position;
Collider2D[] colliders = Physics2D.OverlapCircleAll(explosionPos, radius);
foreach (Collider2D hit in colliders)
{
if (hit.transform.parent && hit.transform.parent.gameObject.HasTag(Tag.Feature) && hit.GetComponentInParent <Destroyer>())
{
hit.GetComponentInParent <Destroyer>().Destroy();
}
Rigidbody2D r = hit.GetComponent <Rigidbody2D>();
if (r != null)
{
r.AddExplosionForce(power, explosionPos, radius, 3.0F);
}
}
FX_Spawner.instance.SpawnFX(FXType.SmallExplosion, transform.position, Quaternion.identity);
Destroy(gameObject);
}
void Explode(Hit hit)
{
gameObject.SetActive(true);
//randomly choose an disintegration type
switch (Rand.Range(1, 1))
{
case 0:
disintegration = Type.Explosion;
break;
case 1:
disintegration = Type.Directional_Explosion;
break;
case 2:
disintegration = Type.Slump;
break;
case 3:
disintegration = Type.Directional_Slump;
break;
case 4:
disintegration = Type.Geyser;
break;
default:
Assert.IsTrue(false, "** Default Case Reached **");
break;
}
//cycle through pieces and send them flying
foreach (Transform child in transform)
{
int direction;
//activate physics on this piece
Rigidbody2D childRigidbody2D = child.GetComponent <Rigidbody2D>();
childRigidbody2D.isKinematic = false;
//start countdown towards this piece fading out
BreakablePiece piece = child.GetComponent <BreakablePiece>();
piece.CountDown();
//apply disintegrations!
switch (disintegration)
{
case Type.Explosion:
childRigidbody2D.AddExplosionForce(2000, transform.position, 20);
break;
case Type.Directional_Explosion:
int force = (hit.horizontalSide == Side.Right) ? -50 : 50;
childRigidbody2D.AddForce(new Vector3(force, 50, 50), ForceMode2D.Impulse);
// params = duration, strength, vibrato, randomness.
EventKit.Broadcast("shake camera", .7f, .4f, 20, 3f);
break;
case Type.Slump:
childRigidbody2D.AddExplosionForce(250, transform.position, 3);
break;
case Type.Directional_Slump:
direction = (hit.horizontalSide == Side.Right) ? 1 : -1;
childRigidbody2D.AddForce(new Vector3(0, -100, 0));
childRigidbody2D.AddExplosionForce(800, new Vector3(
transform.position.x + direction,
transform.position.y + .5f,
transform.position.z), 2
);
break;
case Type.Geyser:
childRigidbody2D.AddForce(new Vector3(0, -75, 0), ForceMode2D.Impulse);
break;
default:
Assert.IsTrue(false, "** Default Case Reached **");
break;
}
}
}
// Called by explosion to push bones around
public void AddExplosionForce(Vector3 explosionPosition)
{
rb.AddExplosionForce(1000, new Vector2(explosionPosition.x, explosionPosition.y), 1500);
}