如何在继承的类中使用抽象方法？

Question

I'm currently working on a school project that's due to friday & I've got a whole lot to do. The assignment is to make a video game with XNA framework using Monogame. I'm currently working with collisions.

The structure for gameobjects looks somewhat like this:

For collisions, I have a simple collision class

     class Collision{

public GameObject Other;

public GameObject Obj1;

public Collision(GameObject obj1, GameObject other)
{
    Other = other;
    Obj1 = obj1;
}}

The collisions are handled in a static method in the GameObject class:

public static void UpdateCollisions()
{
    //Empty the list
    AllCollisions.Clear();

    for (int a = 0; a < AllGameObjectsWithCollision.Count; a++)
    {
        GameObject obja = AllGameObjectsWithCollision[a];
        for (int b = 0; b < AllGameObjectsWithCollision.Count; b++)
        {
            GameObject objb = AllGameObjectsWithCollision[b];

            if (obja.Mask != null & objb.Mask!= null && obja != objb)
            {
                if (obja.Mask.CollisionRectangle.Intersects(objb.Mask.CollisionRectangle))
                    AllCollisions.Add(new Collision(obja, objb));
            }
        }
    }

}

This far it's working, the game is finding all collisions like it should. However now I need to let my objects know that they're colliding, and tell them what to do. For this, I made the entity class abstract to be able to declare an abstract method called "OnCollision(Collision collision)"

 abstract class Entity : GameObject { public float Health; public float MaxHealth; public bool Alive; public float OriginalDmg; public float Dmg; public abstract void OnCollision(Collision collision); } 

Then I'm overriding the method in the classes that inherit the Entity class

Ex. Projectile

 class Projectile : Entity { Entity Owner; ProjectileType pType; public Projectile(Texture2D image, float maxSpeed, Entity owner, float dmg, ProjectileType type) { Image = image; MaxSpeed = maxSpeed; AccelerationSpeed = MaxSpeed; Owner = owner; Dmg = dmg; pType = type; } public override void OnCollision(Collision collision) { #region If this projectile friendly if (pType == ProjectileType.Friendly) { //If colliding with an enemy if (collision.Other.GetType() == typeof(Enemy)) { var enemy = (Enemy)collision.Other; enemy.Health -= Dmg; Destroy(this); } } #endregion #region If this projectile is hostile if (pType == ProjectileType.Hostile) { } #endregion } } 

Then I'm trying to call the OnCollision method from my Update in the GameObject class. This is how I try to inform my objects if they are collding and who they're colliding with:

  if (GetType().IsAssignableFrom(typeof(Entity))) { Entity entity = (Entity)this; if (GetType() == typeof(Player)) entity = (Player)this; if (GetType() == typeof(Enemy)) entity = (Enemy)this; if (GetType() == typeof(Projectile)) entity = (Projectile)this; var entityCol = FindCollision(entity); if (entityCol != null) entity.OnCollision(entityCol); } 

I'm new to abstract classes & overriding, so I might have gotten the whole idea wrong. But it seems the OnCollision method isn't reached as I've tried to Debug.WriteLine stuff but nothing shows up in the output window.

Thanks for reading & perhaps trying to help me out :)

Mediafire link to download the project in case you want to see all the code.

Answer 1

You should read up on interfaces . An interface provides a contract (a bunch of methods and properties) that deriving classes must implement. Abstract classes are more concrete than interfaces in that they can also provide a base implementation for deriving classes. You can only derive from one abstract class whereas you can derive from multiple interfaces. From the code in your post it looks like you are using an abstract class like an interface.

You are using reflection to do type checking. There's the is keyword for testing type compatibility. For example:

if(entity is Player)
{
    var player = (Player)entity;

    // player specific code
}

Finally; from what I can gather from your post it looks like you aren't quite using inheritance correctly. It looks like you are correctly using inheritance to build a type hierarchy but then putting all the logic in a base class.

Inheritance is meant to let you put the specialized logic in the appropriate class.

public interface IGameObject
{
    void OnCollision(IGameObject target);
}

public class Player : IGameObject
{
    public void OnCollision(IGameObject target)
    {
         Console.WriteLine("Player collision");
    }
}

public class Projectile : IGameObject
{
    public void OnCollision(IGameObject target)
    {
         Console.WriteLine("Projectile collision");
    }
}

When we then have a reference to a IGameObject and call OnCollision the appropriate OnCollision function will automatically be called. For example:

IGameObject player = new Player();
IGameObject projectile = new Projectile();

player.OnCollision(projectile);
projectile.OnCollision(player);

Output:

Player collision
Projectile collision

Answer 2

Eh, wrong if statement...

Using

if (GetType().IsSubclassOf(typeof(Entity)))

fixed it.

Silly mistake, my bad.