/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
protected override bool Collide(MobileObject other)
{
// Players can walk through each other
if (other is Player)
{
return(false);
}
else if (other is Bomb)
{
// TODO: kicking/punching
return(true);
}
else if (other is Explosion)
{
// Players shouldn't die on the tiniest touch of the explosion.
// Leave them half a field of room in each direction
// -> this is respected here. The explosion itself is only in the
// center of the field, so a collision is only raised if
// we actually walk through the center!
// see also Bomb.Explode
Die();
return(false);
}
else if (other is Powerup)
{
Powerup pup = (Powerup)other;
pup.Affect(this);
return(false);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="player"></param>
/// <remarks>
/// TODO: is this sensible? Here?
/// </remarks>
public void AddPlayer(Player player)
{
float x = player.X;
float y = player.Y;
float w = player.Width;
float h = player.Height;
for (int i = 0; i < Items.Count; ++i)
{
MobileObject other = Items[i];
if (other == player)
{
continue;
}
if (new RectangleF(x + 0.5f * w - 1.0f, y + 0.5f * h - 1.0f, 2.0f, 2.0f).IntersectsWith(new RectangleF(other.Position, other.Size)) &&
!(other is Stone) && !(other is Player))
{
System.Console.WriteLine("Removing a " + other + " from (" + other.X + ", " + other.Y + ")");
Items.Remove(other);
--i;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
protected override bool Collide(MobileObject other)
{
return(true);
}
private bool IsExplosionStopper(Board board, int x, int y, List <Bomb> triggeredBombs)
{
bool result = false;
RectangleF rect = new RectangleF(x, y, 1.0f, 1.0f);
for (int i = 0; i < board.Items.Count; ++i)
{
MobileObject obj = board.Items[i];
if (rect.IntersectsWith(new RectangleF(obj.Position, obj.Size)))
{
if (obj is Wall)
{
((Wall)obj).Explode();
System.Console.WriteLine("Explosion hit wall at ({0}, {1})", x, y);
result = true;
}
else if (obj is Stone)
{
System.Console.WriteLine("Explosion stopped by stone at ({0}, {1})", x, y);
return(true);
}
else if (obj is Player)
{
// TRYTRY/HACKHACK: this is necessary. And a relatively nice way
// of doing it. But can we still improve that?
// Players shouldn't die on the tiniest touch of the explosion.
// Leave them half a field of room in each direction
// NOTE: an analogous check has to happen in Player.Collide
if (rect.Contains(obj.X + 0.5f, obj.Y + 0.5f))
{
((Player)obj).Die();
}
}
else if (obj is Powerup)
{
board.Items.RemoveAt(i--);
}
else if (obj is Bomb && obj != this)
{
triggeredBombs.Add(((Bomb)obj));
// A bomb stops an explosion.
// Yes, that means bombs with short range stop explosions
// with much larger range. That is desired behaviour!
// (At least that's how it works in AB) TRYTRY
return(true);
}
else if (obj is Explosion)
{
return(true);
}
}
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
protected override bool Collide(MobileObject other)
{
// powerups shouldn't move, so they really shouldn't collide with anything
throw new System.InvalidOperationException("Powerup colliding with " + other);
}
/// <summary> /// When overridden in a derived class, handles collision with /// another object. /// </summary> /// <param name="other"> /// the object with which a collision is occuring /// </param> /// <returns> /// <c>false</c> if the object can move on, /// <c>true</c> if the collision caused the object to stop /// </returns> protected abstract bool Collide(MobileObject other);
