我使用各种形状进行碰撞检测(Rectangle、Circle、Cone、Ring 等)所有这些形状派生自基本抽象 Shape 类。我的游戏对象具有 Shape 类型的属性。

class GameObject
{
    (...)
    public Shape CollisionShape { get; set; }
}

在初始化过程中，我决定每个对象将使用什么形状，例如:

GameObject person = new GameObject();
person.CollisionShape = new Circle(100); // 100 is radius

现在，当我想检查两个对象是否相交时，我使用以下类:

public class IntersectionChecker
{
   public bool Intersect(Shape a, Shape b)
   {
      Type aType = a.GetType();
      Type bType = b.GetType();

      if( aType == typeof(Rectangle) && bType == typeof(Rectangle))
          return Intersect(a as Rectangle, b as Rectangle);

      if( aType == typeof(Rectangle) && bType == typeof(Circle))
          return Intersect(a as Rectangle, b as Circle);

      // etc. etc. All combinations      
   }

   private bool Intersect(Rectangle a, Rectangle b)
   {
      // check intersection between rectangles
   }
}

所以我的代码看起来像:

IntersectionChecker ic = new IntersectionCHecker();
bool isIntersection = 
    is.Intersect(personA.CollisionShape, personB.CollisionShape);

有没有更好的方法来实现我的目标，而无需在 IntersectionChecker 类中进行大量“if”检查和类型检查？

编辑:

请记住，检查形状 A 和 B 之间交集的方法也可以用于检查 B 和 A 之间的交集。在许多答案中(感谢您的所有想法!)建议从形状本身而不是 IntersectionChecker 对象调用相交检查。我认为这会迫使我重复代码。现在我可以做如下:

  if( aType == typeof(Rectangle) && bType == typeof(Circle))
      return Intersect(a as Rectangle, b as Rectangle);

  if( aType == typeof(Circle) && bType == typeof(Rectangle))
      return Intersect(b as Rectangle, a as Circle); // same method as above

最佳答案

您可以使用 Visitor Pattern , here is a C# example

这将允许您简单地拥有 Shape.Intersect(Rectangle), Shape.Intersect(Circle), ... 每个派生形状实现的方法。它将避免您不得不以额外的方法调用为代价对类型进行任何反射(reflection)。

编辑 - 这是一个示例实现，如果 Shape 中没有共享功能，使用接口(interface) IShape 可能会更清晰，但我只是停留在抽象基类中。

public class GameObject
{
    private Shape _collisionShape;

    public GameObject(Shape collisionShape)
    {
        _collisionShape = collisionShape;
    }

    public bool Intersects(GameObject other)
    {
        return _collisionShape.IntersectVisit(other._collisionShape);
    }
}

public abstract class Shape
{
    public abstract bool IntersectVisit(Shape other);
    public abstract bool Intersect(Circle circle);
    public abstract bool Intersect(Rectangle circle);
}

public class Circle : Shape
{
    public override bool IntersectVisit(Shape other)
    {
        return other.Intersect(this);
    }

    public override bool Intersect(Circle circle)
    {
        Console.WriteLine("Circle intersecting Circle");
        return false; //implement circle to circle collision detection
    }

    public override bool Intersect(Rectangle rect)
    {
        Console.WriteLine("Circle intersecting Rectangle");
        return false; //implement circle to rectangle collision detection
    }
}

public class Rectangle : Shape
{
    public override bool IntersectVisit(Shape other)
    {
        return other.Intersect(this);
    }

    public override bool Intersect(Circle circle)
    {
        Console.WriteLine("Rectangle intersecting Circle");
        return true; //implement rectangle to circle collision detection
    }

    public override bool Intersect(Rectangle rect)
    {
        Console.WriteLine("Rectangle intersecting Rectangle");
        return true; //implement rectangle to rectangle collision detection
    }
}

以及调用它的示例代码:

GameObject objectCircle = new GameObject(new Circle());
GameObject objectRect = new GameObject(new Rectangle());

objectCircle.Intersects(objectCircle);
objectCircle.Intersects(objectRect);
objectRect.Intersects(objectCircle);
objectRect.Intersects(objectRect);

产生输出:

Circle intersecting Circle
Rectangle intersecting Circle
Circle intersecting Rectangle
Rectangle intersecting Rectangle

关于c# - 检查形状之间碰撞的设计模式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6163457/