Diseño modelo para la comprobación de colisión entre las formas

Question

utilizo varias formas para la detección de colisión (Rectangle, Circle, Cone, Ring etc.) Todas esas formas se derivan de la clase base abstracta Shape. Mis objetos del juego tienen propiedad de tipo Shape.

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

y durante el proceso de inicialización que decida qué forma se utilizará para cada objeto, como:

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

Ahora cuando quiero comprobar si dos objetos se cruza utilizo la clase siguiente:

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 
    } 
} 

por lo que mi código es el siguiente:

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

¿Hay alguna forma mejor de lograr mi objetivo, sin docenas de controles 'if' y controles de tipo en la clase IntersectionChecker?

EDIT:

Por favor tome en cuenta, que el método que se compruebe la intersección entre la forma A y B se puede utilizar para comprobar la intersección entre B y A también. En muchas respuestas (¡gracias por todos sus pensamientos!), Se propone que la comprobación de intersección se invoque desde la propia forma en lugar del objeto IntersectionChecker. Creo que me obligará a duplicar el código. Ahora puedo hacer de la siguiente manera:

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 

Answer 1

podría utilizar el Visitor Pattern, here is a C# example

Eso le permitiría simplemente tener Shape.Intersect (Rectangle), Shape.Intersect (Circle), ... métodos que implementa cada forma derivada. Evitaría tener que reflexionar sobre los tipos a costa de una llamada a un método adicional.

EDIT - Aquí hay una implementación de ejemplo, probablemente sería más limpio usar una interfaz IShape si no hay una funcionalidad compartida que entraría en Shape, pero simplemente me quedé en una clase base abstracta.

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 
    } 
} 

Y ejemplo de código llamándolo:

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

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

produce la salida:

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

Answer 2

Se podría diferir de su clase Shape para realizar el control de colisión, la adición de un método IntersectsWith(Shape other) a la forma. También le sugiero agregar un IntersectsWith(GameObject other) a su GameObject que le permite mantener su CollisionShape en privado.

Answer 3

Si los controles tendrían que residir en algún lugar de todos modos.

Se podría añadir un Intersects método para Shape:

abstract class Shape 
{ 
    public abstract Boolean Intersects(Shape other); 
} 

luego hacer su Intersect métodos en IntersectionCheckerpublic static e implementar Intersects método para cada forma concreta así:

class Rectangle : Shape 
{ 
    public override Boolean Intersects(Shape other) 
    { 
     if (other is Rectangle) 
     { 
      return IntersectionChecker.Intersect(this, (Rectangle)other); 
     } 
     else if (other is Circle) 
     { 
      return IntersectionChecker.Intersect(this, (Circle)other); 
     } 

     throw new NotSupportedException(); 
    } 
} 

Answer 4

No hay acumulación de fácil solución para su problema. Lo que necesita se llama "envío doble", que solo se admite en idiomas como Smalltalk o Lisp. Todas las soluciones propuestas te obligarán a cambiar todas las clases derivadas si agregas una nueva clase. ¡Eso es un código malo!

Me gustaría abordar el problema de esta manera: Implemente sus clases derivadas de forma sin ningún código de intersección. A continuación, implementar una clase de intersección de esta manera:

public class Intersection { 
    public bool Intersect(Shape a, Shape b) {....} 

    private bool Intersect(Rectangle a, Circle b) {...} 

    private bool Intersect(Circle a, Circle b) {...} 
} 

Los métodos públicos los análisis de las formas de entrada y despachos (-> doble de despacho) el trabajo con el método privada correspondiente. Que contiene la lógica de intersección sin procesar. La implementación de Intersect no necesita "ifs". Puede usar la reflexión para encontrar el mejor método de coincidencia. Los detalles dependen de sus requisitos exactos y de cómo pondere la complejidad frente al rendimiento. Pero es fácil comenzar con una implementación simple y directa. Como todo está encapsulado en un solo lugar, es fácil optimizarlo más adelante. Lo cual es un buen enfoque en mi opinión. ;-)