Salut,
j'ai un petit soucis au niveau code design, je m'explique :
J'ai une classe Entity, elle n'hérite de rien, elle contient juste un id et le type de l'entité et une variable booléenne pour savoir si l'entité est dynamique ou pas, cette classe est abstaite.
J'ai une classe TransfomableEntity qui hérite de Entity et qui contient un sf::Transform, cette classe est abstraite.
J'ai une classe DrawableEntity qui hérite de sf::Drawable et de Entity, cette classe est aussi abstraite.
J'ai de nouveau 2 classes abstraites, StaticDrawableEntity qui hérite de DrawableEntity et DynamicDrawableEntity qui hérite de DrawableEntity et de TransformableEntity, toujours abstraites.
Et j'ai une classe TexturedEntity qui hérite juste de DrawableEntity, elle est abstraite.
Sur le shéma ça donne ceci :
------------------- ------------------ ------------------------
| sf::Drawable | | Entity | | sf::Transormable |
| | | | | |
------------------- ------------------ ------------------------
| | | |
--------------------------- ---------------------------
| DrawableEntity | | TransformableEntity |
| | | |
--------------------------- ---------------------------
| | | |
------------------------- ------------------ -----------------------------
|StaticDrawableEntity| |TexturedEntity| |DynamicDrawableEntity|
| | | | | |
------------------------- ------------------- -----------------------------
Alors tout ce qui dérive de DynamicDrawableEntity est transformble et dessinable, il faut redéfinir la méthode draw, on peut redéfinir aussi d'autre méthodes si y'a quelque chose à faire lorsqu'on effectue une transformation. (une rotation, un changement d'échelle ou bien une translation.)
On peut appeler les méthodes qui change la géométrie d'une entité que si elle dérive de cette classe, à l'inverse des classes qui dérivent de StaticDrawableEntity.
Tout ce qui dérive de StaticDrawableEntity est dessinable mais pas transformable, il faut redéfinir la méthode draw donc.
Une classe peut donc dériver de StaticDrawableEntity ou de DynamicDrawableEntity mais elle peut aussi dériver de TexturedEntity si l'entité est texturée et là il faut redéfinir les méthodes getTexture et getTextureRect.
Voici les autres classes qui dérivent de ces différentes classes : Tile qui dérive de DynamicDrawableEntity et de TexturedEntity, même chose pour les classes Wall et Decor.
Light dérive de StaticDrawableEntity seulement.
Shadow dérive de DynamicDrawableEntity seulement.
Le problème va se poser maintenant : j'ai une classe World qui permet d'ajouter des entités dans le monde, dans cette classe monde il y a une casse map qui contient des informations comme par exemple : le nombre de fois qu'une texture est utilisée sur la map, le nom de la map, etc...
Chaque map contient une grille dans laquelle sont ajouté les entités.
Bref dans cette grille tout mes objets sont de type entité.
Donc je suis obligé de faire hériter toutes mes classes de la classe Entity pour ensuite faire des static_cast et j'ai ainsi plusieurs méthodes selon le type d'entité que je veux récupérer dans la grille et faire ce que je veux si y'a des opérations spéciale à faire lorsque je rajoute, transforme ou supprime une entité dans le monde. (Par exemple si l'entité est texturée, qu'elle est supprimée et que la texture n'est plus utilisée par aucune autre entité, la supprimer.)
Cependant il y a un gros problème, lorsque je veux ajouter une entité dans le monde, une tile par exemple, avec la méthode World::addEntity (Entity *entity), il me dit qu'il y a une ambiguité à l'endroit ou j'appelle cette méthode car Tile dérive de TexturedEntity qui dérive de Entity, mais Tile dérive aussi de DynamcDrawableEntity qui dérive aussi de Entity.
Je suis obligé de faire dérivé les 2 de entity sinon je peux pas faire de cast de Entity vers DynamicDrawableEntity ou bien vers TexturedEntity.
Et je vois pas trop comment résoudre ce problème d'ambiguité.
Merci d'avance pour votre aide.
