Jusqu'à présent, toutes les entités étaient représentées par des carrés.
Pour ajouter de nouvelles formes (rectangles, cercles, ellipses, etc.), il serait possible de créer un type différent pour chacune d'elles.
Cette solution conduirait toutefois à dupliquer du code et obligerait la structure Window à traiter chaque type de forme différemment.

L'objectif est au contraire que toutes les formes graphiques puissent être manipulées de manière uniforme.
Pour cela, elles doivent partager une même abstraction définissant les opérations qu'une forme graphique doit fournir.

En Rust, cette abstraction est représentée par un trait, qui joue le rôle d'une interface.

Le diagramme de classes suivant présente la nouvelle architecture :

L'entité ne sera plus responsable de son dessin.
Elle possédera désormais un objet implémentant le trait Shape, quelle que soit sa forme concrète.

Déclarez le trait✍ Shape dans le fichier simu.rs.

En analysant les responsabilités actuelles de la structure Entity, on constate que deux opérations dépendent exclusivement de la forme graphique :

Le trait Shape devra donc déclarer les deux méthodes abstraites suivantes : Le trait ne fournit ici aucune implémentation : chaque type de forme graphique définira son propre comportement en réalisant ce trait.

Le premier type implémentant Shape sera la structure Rectangle.

Déclarez le type Rectangle dans un nouveau fichier shapes.rs, qui regroupera les différentes formes graphiques du projet.

Définissez les données membres indiquées dans le diagramme de classes ainsi qu'un constructeur new().

Implémentez ensuite le trait Shape pour ce type.

La méthode bounding_radius() renverra le rayon du cercle englobant du rectangle, c'est-à-dire la moitié de sa diagonale.

La méthode draw() reprend le principe de celle précédemment implémentée dans Entity, mais l'adapte au cas général d'un rectangle.
Comme la position et la couleur appartiennent désormais à l'entité et non à la forme graphique, elles sont fournies en paramètres de la méthode.
Entity devra donc permettre un accès en lecture à ces informations.

Prenez également en compte l'attribut filled, qui indique si le rectangle doit être dessiné plein ou sous forme de contour.

Une fois cette première implémentation terminée, vous pourrez modifier la structure Entity afin qu'elle délègue les opérations liées à la forme graphique à un objet implémentant le trait Shape.

L'entité n'est désormais plus responsable de son dessin.
Conformément au diagramme de classes, elle possède une composition avec un objet implémentant le trait Shape.

En Rust, lorsqu'un objet est manipulé à travers un trait, il faut indiquer explicitement que l'on souhaite utiliser le polymorphisme dynamique.
On utilise alors le mot-clé dyn.
On pourrait donc être tenté d'écrire : Cependant, cette écriture est impossible.
Un objet de type dyn Shape n'a pas de taille connue à la compilation, alors que tous les champs d'une structure doivent avoir une taille fixe.

Il faut donc placer l'objet derrière un pointeur de taille connue : Box est un pointeur propriétaire : l'objet est alloué sur le tas (heap) et appartient à Entity, conformément à la relation de composition du diagramme de classes.
La taille du champ shape est alors simplement celle du pointeur, que le compilateur connaît.

Cette modification a plusieurs conséquences sur la structure Entity :

Les attributs propres à la forme graphique (dimensions et rayon du cercle englobant) n'ont donc plus leur place dans Entity.

Le constructeur ayant changé, adaptez également la fonction create_window() du fichier lib.rs.
Avant de créer chaque entité, instanciez un Rectangle, placez-le dans un

{TT|Box<dyn Shape>}

et transmettez-le au constructeur de Entity.

Les rectangles auront une largeur et une hauteur aléatoires comprises entre 50 et 100.
Faites en sorte que la moitié d'entre eux soient pleins et l'autre moitié dessinés sous forme de contour.
Lisez bien la fonction create_window() : vous disposez déjà de toutes les informations nécessaires.

À l'issue de cette étape, la fenêtre doit afficher 8 rectangles pleins et 8 rectangles vides, tous animés et interactifs.

En vous appuyant sur l'implémentation de Rectangle, ajoutez une nouvelle structure Circle.

Avant de commencer, complétez le diagramme de classes en y ajoutant Circle et identifiez les données membres nécessaires à la représentation d'un cercle.

Implémentez ensuite le trait Shape pour cette nouvelle structure.

Pour dessiner un cercle, utilisez la méthode ellipse() du type s5::Screen.
Cette fonction reçoit le rectangle englobant de l'ellipse ; dans le cas d'un cercle, il s'agit donc d'un carré de côté égal à deux fois le rayon.

Modifiez enfin la fonction create_window() afin que la fenêtre contienne : chaque entité possédant sa propre taille, sa couleur et ses propriétés cinématiques.

Testez votre application : la fenêtre doit maintenant afficher des rectangles et des cercles, tous animés et interactifs.