/// <summary>
/// Kills this object, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
if (!cleanupOnly)
{
// play the explosion sound
AudioManager.PlaySoundEffect("explosion_medium");
// display the rocket explosion
if (ParticleEffectManager != null)
{
ParticleEffectManager.SpawnEffect(
ParticleEffectType.RocketExplosion, Position);
}
}
// stop the rocket-flying sound effect
if (rocketSound != null)
{
rocketSound.Stop(true);
rocketSound.Dispose();
rocketSound = null;
}
// stop the rocket-trail effect
if (rocketTrailEffect != null)
{
rocketTrailEffect.Stop(false);
}
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Update the particle effect.
/// </summary>
/// <param name="elapsedTime">The amount of elapsed time, in seconds.</param>
public virtual void Update(float elapsedTime)
{
// update the position based on the follow-object, if any
if (followObject != null)
{
if (followObject.Active)
{
Position = followObject.Position;
}
else
{
followObject = null;
Stop(false);
}
}
// update each system
active = false;
for (int i = 0; i < particleSystems.Count; ++i)
{
if (particleSystems[i].Active)
{
particleSystems[i].Update(elapsedTime);
active = true;
}
}
}
/// <summary>
/// Defines the interaction between this projectile and a target GameplayObject
/// when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public override bool Touch(GameplayObject target)
{
// check the target, if we have one
if (target != null)
{
// don't bother hitting any power-ups
if (target is PowerUp)
{
return(false);
}
// don't hit the owner if the damageOwner flag isn't set
if ((this.damageOwner == false) && (target == owner))
{
return(false);
}
// don't hit other projectiles from the same ship
Projectile projectile = target as Projectile;
if ((projectile != null) && (projectile.Owner == this.Owner))
{
return(false);
}
// damage the target
target.Damage(this, this.damageAmount);
}
// either we hit something or the target is null - in either case, die
Die(target, false);
return(base.Touch(target));
}
/// <summary>
/// Kills this ship, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
if (!cleanupOnly)
{
// update the score
Ship ship = source as Ship;
if (ship == null)
{
Projectile projectile = source as Projectile;
if (projectile != null)
{
ship = projectile.Owner;
}
}
if (ship != null)
{
if (ship == this)
{
// reduce the score, since i blew myself up
ship.Score--;
}
else
{
// add score to the ship who shot this object
ship.Score++;
}
}
else
{
// if it wasn't a ship, then this object loses score
this.Score--;
}
// play the player-death sound
AudioManager.PlaySoundEffect("explosion_shockwave");
AudioManager.PlaySoundEffect("explosion_large");
// display the ship explosion
if (ParticleEffectManager != null)
{
ParticleEffectManager.SpawnEffect(
ParticleEffectType.ShipExplosion, Position);
}
}
// clear out the projectiles list
foreach (Projectile projectile in projectiles)
{
projectile.Die(null, true);
}
projectiles.Clear();
// set the respawn timer
respawnTimer = respawnTimerOnDeath;
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Defines the interaction between the asteroid and a target GameplayObject
/// when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public override bool Touch(GameplayObject target)
{
// if the asteroid has touched a player, then damage it
Ship player = target as Ship;
if (player != null)
{
// calculate damage as a function of how much the two GameplayObject's
// velocities were going towards one another
Vector2 playerAsteroidVector = Position - player.Position;
if (playerAsteroidVector.LengthSquared() > 0)
{
playerAsteroidVector.Normalize();
float rammingSpeed =
Vector2.Dot(playerAsteroidVector, player.Velocity) -
Vector2.Dot(playerAsteroidVector, Velocity);
float momentum = Mass * rammingSpeed;
player.Damage(this, momentum * momentumToDamageScalar);
}
}
// if the asteroid didn't hit a projectile, play the asteroid-touch sound effect
if ((target is Projectile) == false)
{
AudioManager.PlaySoundEffect("asteroid_touch");
}
return(true);
}
/// <summary>
/// Kills this object, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public virtual void Die(GameplayObject source, bool cleanupOnly)
{
// deactivate the object
if (active)
{
active = false;
CollisionManager.Collection.QueuePendingRemoval(this);
}
}
/// <summary>
/// Defines the interaction between this power-up and a target GameplayObject
/// when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public override bool Touch(GameplayObject target)
{
// if we hit a ship, give it the weapon
Ship ship = target as Ship;
if (ship != null)
{
ship.Weapon = new DoubleLaserWeapon(ship);
}
return base.Touch(target);
}
/// <summary>
/// Spawn a new particle effect at a the position of a given gameplay object
/// </summary>
/// <param name="effectType">The effect in question.</param>
/// <param name="actor">The gameplay object.</param>
/// <returns>The new particle effect.</returns>
public ParticleEffect SpawnEffect(ParticleEffectType effectType,
GameplayObject gameplayObject)
{
// safety-check the parameter
if (gameplayObject == null)
{
throw new ArgumentNullException("gameplayObject");
}
return(SpawnEffect(effectType, gameplayObject.Position, gameplayObject));
}
/// <summary>
/// Defines the interaction between this power-up and a target GameplayObject
/// when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public override bool Touch(GameplayObject target)
{
// if we hit a ship, give it the weapon
Ship ship = target as Ship;
if (ship != null)
{
ship.Weapon = new DoubleLaserWeapon(ship);
}
return(base.Touch(target));
}
/// <summary>
/// Kills this projectile, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
if (!cleanupOnly)
{
CollisionManager.Explode(this, source, damageAmount, Position,
damageRadius, damageOwner);
}
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Kills this object, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
// display the laser explosion
if (!cleanupOnly && (ParticleEffectManager != null))
{
ParticleEffectManager.SpawnEffect(ParticleEffectType.LaserExplosion,
Position);
}
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Defines the interaction between this power-up and a target GameplayObject
/// when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public override bool Touch(GameplayObject target)
{
// if it touched a ship, then create a particle system and play a sound
Ship ship = target as Ship;
if (ship != null)
{
// play the "power-up picked up" sound effect
AudioManager.PlaySoundEffect("powerup_touch");
// kill the power-up
Die(target, false);
// the ship keeps going as if it didn't hit anything
return(false);
}
return(base.Touch(target));
}
/// <summary>
/// Kills this object, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
if (!cleanupOnly)
{
// play the explosion sound effect
AudioManager.PlaySoundEffect("explosion_large");
// play the mine particle-effect
if (ParticleEffectManager != null)
{
ParticleEffectManager.SpawnEffect(
ParticleEffectType.MineExplosion, Position);
}
}
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Damage this ship by the amount provided.
/// </summary>
/// <remarks>
/// This function is provided in lieu of a Life mutation property to allow
/// classes of objects to restrict which kinds of objects may damage them,
/// and under what circumstances they may be damaged.
/// </remarks>
/// <param name="source">The GameplayObject responsible for the damage.</param>
/// <param name="damageAmount">The amount of damage.</param>
/// <returns>If true, this object was damaged.</returns>
public override bool Damage(GameplayObject source, float damageAmount)
{
// if the safe timer hasn't yet gone off, then the ship can't be hurt
if ((safeTimer > 0f) || (damageAmount <= 0f))
{
return(false);
}
// once you're hit, the shield-recharge timer starts over
shieldRechargeTimer = 2.5f;
// damage the shield first, then life
if (shield <= 0f)
{
life -= damageAmount;
}
else
{
shield -= damageAmount;
if (shield < 0f)
{
// shield has the overflow value as a negative value, just add it
life += shield;
shield = 0f;
}
}
Projectile sourceAsProjectile = source as Projectile;
if (sourceAsProjectile != null)
{
lastDamagedBy = sourceAsProjectile.Owner;
}
else
{
lastDamagedBy = source;
}
return(true);
}
/// <summary>
/// Spawn a new particle effect at a given location and gameplay object
/// </summary>
/// <param name="effectType">The effect in question.</param>
/// <param name="position">The position of the effect.</param>
/// <param name="actor">The gameplay object.</param>
/// <returns>The new particle effect.</returns>
public ParticleEffect SpawnEffect(ParticleEffectType effectType,
Vector2 position, GameplayObject gameplayObject)
{
ParticleEffect particleEffect = null;
if (particleEffectCache.ContainsKey(effectType) == true)
{
List <ParticleEffect> availableSystems = particleEffectCache[effectType];
for (int i = 0; i < availableSystems.Count; ++i)
{
if (availableSystems[i].Active == false)
{
particleEffect = availableSystems[i];
break;
}
}
if (particleEffect == null)
{
particleEffect = availableSystems[0].Clone();
particleEffect.Initialize(contentManager);
availableSystems.Add(particleEffect);
}
}
if (particleEffect != null)
{
particleEffect.Reset();
particleEffect.GameplayObject = gameplayObject;
particleEffect.Position = position;
activeParticleEffects.Add(particleEffect);
}
return(particleEffect);
}
/// <summary>
/// Kills this projectile, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
if (!cleanupOnly)
{
CollisionManager.Explode(this, source, damageAmount, Position,
damageRadius, damageOwner);
}
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Defines the interaction between this projectile and a target GameplayObject
/// when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public override bool Touch(GameplayObject target)
{
// check the target, if we have one
if (target != null)
{
// don't bother hitting any power-ups
if (target is PowerUp)
{
return false;
}
// don't hit the owner if the damageOwner flag isn't set
if ((this.damageOwner == false) && (target == owner))
{
return false;
}
// don't hit other projectiles from the same ship
Projectile projectile = target as Projectile;
if ((projectile != null) && (projectile.Owner == this.Owner))
{
return false;
}
// damage the target
target.Damage(this, this.damageAmount);
}
// either we hit something or the target is null - in either case, die
Die(target, false);
return base.Touch(target);
}
/// <summary>
/// Kills this object, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
if (!cleanupOnly)
{
// play the explosion sound
AudioManager.PlaySoundEffect("explosion_medium");
// display the rocket explosion
if (ParticleEffectManager != null)
{
ParticleEffectManager.SpawnEffect(
ParticleEffectType.RocketExplosion, Position);
}
}
// stop the rocket-flying sound effect
if (rocketSound != null)
{
rocketSound.Stop(true);
rocketSound.Dispose();
rocketSound = null;
}
// stop the rocket-trail effect
if (rocketTrailEffect != null)
{
rocketTrailEffect.Stop(false);
}
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Kills this object, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
// display the laser explosion
if (!cleanupOnly && (ParticleEffectManager != null))
{
ParticleEffectManager.SpawnEffect(ParticleEffectType.LaserExplosion,
Position);
}
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Defines the interaction between the asteroid and a target GameplayObject
/// when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public override bool Touch(GameplayObject target)
{
// if the asteroid has touched a player, then damage it
Ship player = target as Ship;
if (player != null)
{
// calculate damage as a function of how much the two GameplayObject's
// velocities were going towards one another
Vector2 playerAsteroidVector = Position - player.Position;
if (playerAsteroidVector.LengthSquared() > 0)
{
playerAsteroidVector.Normalize();
float rammingSpeed =
Vector2.Dot(playerAsteroidVector, player.Velocity) -
Vector2.Dot(playerAsteroidVector, Velocity);
float momentum = Mass * rammingSpeed;
player.Damage(this, momentum * momentumToDamageScalar);
}
}
// if the asteroid didn't hit a projectile, play the asteroid-touch sound effect
if ((target is Projectile) == false)
{
AudioManager.PlaySoundEffect("asteroid_touch");
}
return true;
}
/// <summary>
/// Defines the interaction between this GameplayObject and
/// a target GameplayObject when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public virtual bool Touch(GameplayObject target)
{
return(true);
}
/// <summary>
/// Damage this object by the amount provided.
/// </summary>
/// <remarks>
/// This function is provided in lieu of a Life mutation property to allow
/// classes of objects to restrict which kinds of objects may damage them,
/// and under what circumstances they may be damaged.
/// </remarks>
/// <param name="source">The GameplayObject responsible for the damage.</param>
/// <param name="damageAmount">The amount of damage.</param>
/// <returns>If true, this object was damaged.</returns>
public virtual bool Damage(GameplayObject source, float damageAmount)
{
return(false);
}
/// <summary>
/// Kills this ship, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
if (!cleanupOnly)
{
// update the score
Ship ship = source as Ship;
if (ship == null)
{
Projectile projectile = source as Projectile;
if (projectile != null)
{
ship = projectile.Owner;
}
}
if (ship != null)
{
if (ship == this)
{
// reduce the score, since i blew myself up
ship.Score--;
}
else
{
// add score to the ship who shot this object
ship.Score++;
}
}
else
{
// if it wasn't a ship, then this object loses score
this.Score--;
}
// play the player-death sound
AudioManager.PlaySoundEffect("explosion_shockwave");
AudioManager.PlaySoundEffect("explosion_large");
// display the ship explosion
if (ParticleEffectManager != null)
{
ParticleEffectManager.SpawnEffect(
ParticleEffectType.ShipExplosion, Position);
}
}
// clear out the projectiles list
foreach (Projectile projectile in projectiles)
{
projectile.Die(null, true);
}
projectiles.Clear();
// set the respawn timer
respawnTimer = respawnTimerOnDeath;
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Damage this object by the amount provided.
/// </summary>
/// <remarks>
/// This function is provided in lieu of a Life mutation property to allow
/// classes of objects to restrict which kinds of objects may damage them,
/// and under what circumstances they may be damaged.
/// </remarks>
/// <param name="source">The GameplayObject responsible for the damage.</param>
/// <param name="damageAmount">The amount of damage.</param>
/// <returns>If true, this object was damaged.</returns>
public virtual bool Damage(GameplayObject source, float damageAmount)
{
return false;
}
/// <summary>
/// Kills this object, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public override void Die(GameplayObject source, bool cleanupOnly)
{
if (active)
{
if (!cleanupOnly)
{
// play the explosion sound effect
AudioManager.PlaySoundEffect("explosion_large");
// play the mine particle-effect
if (ParticleEffectManager != null)
{
ParticleEffectManager.SpawnEffect(
ParticleEffectType.MineExplosion, Position);
}
}
}
base.Die(source, cleanupOnly);
}
/// <summary>
/// Spawn a new particle effect at a given location and gameplay object
/// </summary>
/// <param name="effectType">The effect in question.</param>
/// <param name="position">The position of the effect.</param>
/// <param name="actor">The gameplay object.</param>
/// <returns>The new particle effect.</returns>
public ParticleEffect SpawnEffect(ParticleEffectType effectType,
Vector2 position, GameplayObject gameplayObject)
{
ParticleEffect particleEffect = null;
if (particleEffectCache.ContainsKey(effectType) == true)
{
List<ParticleEffect> availableSystems = particleEffectCache[effectType];
for (int i = 0; i < availableSystems.Count; ++i)
{
if (availableSystems[i].Active == false)
{
particleEffect = availableSystems[i];
break;
}
}
if (particleEffect == null)
{
particleEffect = availableSystems[0].Clone();
particleEffect.Initialize(contentManager);
availableSystems.Add(particleEffect);
}
}
if (particleEffect != null)
{
particleEffect.Reset();
particleEffect.GameplayObject = gameplayObject;
particleEffect.Position = position;
activeParticleEffects.Add(particleEffect);
}
return particleEffect;
}
/// <summary>
/// Spawn a new particle effect at a the position of a given gameplay object
/// </summary>
/// <param name="effectType">The effect in question.</param>
/// <param name="actor">The gameplay object.</param>
/// <returns>The new particle effect.</returns>
public ParticleEffect SpawnEffect(ParticleEffectType effectType,
GameplayObject gameplayObject)
{
// safety-check the parameter
if (gameplayObject == null)
{
throw new ArgumentNullException("gameplayObject");
}
return SpawnEffect(effectType, gameplayObject.Position, gameplayObject);
}
/// <summary>
/// Defines the interaction between this GameplayObject and
/// a target GameplayObject when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public virtual bool Touch(GameplayObject target)
{
return true;
}
/// <summary>
/// Defines the interaction between this power-up and a target GameplayObject
/// when they touch.
/// </summary>
/// <param name="target">The GameplayObject that is touching this one.</param>
/// <returns>True if the objects meaningfully interacted.</returns>
public override bool Touch(GameplayObject target)
{
// if it touched a ship, then create a particle system and play a sound
Ship ship = target as Ship;
if (ship != null)
{
// play the "power-up picked up" sound effect
AudioManager.PlaySoundEffect("powerup_touch");
// kill the power-up
Die(target, false);
// the ship keeps going as if it didn't hit anything
return false;
}
return base.Touch(target);
}
/// <summary>
/// Kills this object, in response to the given GameplayObject.
/// </summary>
/// <param name="source">The GameplayObject responsible for the kill.</param>
/// <param name="cleanupOnly">
/// If true, the object dies without any further effects.
/// </param>
public virtual void Die(GameplayObject source, bool cleanupOnly)
{
// deactivate the object
if (active)
{
active = false;
CollisionManager.Collection.QueuePendingRemoval(this);
}
}
/// <summary>
/// Damage this ship by the amount provided.
/// </summary>
/// <remarks>
/// This function is provided in lieu of a Life mutation property to allow
/// classes of objects to restrict which kinds of objects may damage them,
/// and under what circumstances they may be damaged.
/// </remarks>
/// <param name="source">The GameplayObject responsible for the damage.</param>
/// <param name="damageAmount">The amount of damage.</param>
/// <returns>If true, this object was damaged.</returns>
public override bool Damage(GameplayObject source, float damageAmount)
{
// if the safe timer hasn't yet gone off, then the ship can't be hurt
if ((safeTimer > 0f) || (damageAmount <= 0f))
{
return false;
}
// once you're hit, the shield-recharge timer starts over
shieldRechargeTimer = 2.5f;
// damage the shield first, then life
if (shield <= 0f)
{
life -= damageAmount;
}
else
{
shield -= damageAmount;
if (shield < 0f)
{
// shield has the overflow value as a negative value, just add it
life += shield;
shield = 0f;
}
}
Projectile sourceAsProjectile = source as Projectile;
if (sourceAsProjectile != null)
{
lastDamagedBy = sourceAsProjectile.Owner;
}
else
{
lastDamagedBy = source;
}
return true;
}
