Mettre en oeuvre la détection de collision par extendung la classe Rectangle d'utiliser son contient et intersecte méthodes

Question

Je voudrais savoir si cela est une bonne idée que de mettre en œuvre la détection de collision 2D simple des rectangles comme suit:

1. Faire mon propre Classe de détection de collision qui étend la classe Rectangle.
2. Puis lors de l'instanciation de cet objet en faisant quelque chose comme Collision col = new Rectangle(); < - Devrais-je faire cela ou est-ce quelque chose qui devrait être évité? Je suis conscient que je 'peut' mais devrait I? Je veux étendre la classe Rectangle à cause des méthodes et intersects(); devrais-je faire cela ou devrais-je faire autre chose pour la détection de collision 2D en Java?

Answer 1

vous pouvez facilement étendre Rectangle

class CollidableRectangle extends Rectangle 
{ 
    public boolean isCollidingWith(Rectangle otherRect) 
    { 
    //check collision 
    } 

    // return all collisions 
    public List<CollidableRectangle> getCollisions(List<Rectangle) 
    { 
    // code 
    } 
} 

alors vous l'utiliser comme:

CollidableRectangle r1 = new CollidableRectangle(); 
CollidableRectangle r2 = new CollidableRectangle(); 

r1.isCollidingWith(r2); 

//and so on 

Comme il est indiqué dans les commentaires, je n'ai pas utilisé une classe Collision. En général, vous en avez besoin parce que vous êtes également intéressé par les paramètres de collision comme profondeur ou avion entrant en collision de sorte que vous auriez quelque chose comme:

class Collision 
{ 
    CollidableRectangle first, second; 
    float depth; 
    Line2D collidingLine; 
} 

et la méthode renverrait une liste des collisions:

public List<Collision> getCollisions(List<Rectangle) { ... } 

Answer 2

Il n'y a pas de relation is-a entre une collision et un rectangle, une collision n'est pas un rectangle. Un domaine de collision peut avoir des rectangles qui suggèrent que vous utilisez composition. Qu'en est-il de la rendre sans lien avec Rectangle en premier lieu?

Answer 3

Créez un nouveau module de collision autonome et gérez les différents types que vous voulez.

(je ne sais pas Java, désolé pour tous les problèmes ici)

class Collision 
{ 
    public boolean BetweenRectangles(Rectangle a, Rectangle b) 
    { 
    } 

    public boolean BetweenCircles(Circle a, Circle b) 
    { 
    } 

    public boolean RectangleToCircle(Rectangle r, Circle c) 
    { 
    } 

    public boolean MyCrazyShapeToRectangle(MyCrazyShape mcs, Rectangle r) 
    { 
    } 
} 

à mon humble avis, il ne fait pas vraiment de sens pour faire une collision d'un rectangle, car une collision est un concept orthogonal au rectangle, et les brouiller ensemble contraint inutilement vos futures options. La chose clé à réaliser est que vous n'avez pas vraiment besoin d'un objet de collision, en soi, ces fonctions sont de nature procédurale (Java a-t-il quelque chose comme le modificateur statique de C++ pour les fonctions membres de classe-scope?). La collision elle-même n'est pas une propriété de l'un ou l'autre des participants d'une collision.