Généralisez l'architecture mise en place pour Shape afin de rendre les animations polymorphes.

Déclarez dans simu.rs un trait Animator contenant une unique méthode animate().
Cette méthode reçoit :

Implémentez ensuite une première animation concrète en créant la structure Gravity dans un nouveau fichier animators.rs.

Cette structure ne possède aucune donnée membre.
Sa méthode animate() ajoute 10.0 * 9.81 * dt à la composante verticale de la vitesse de l'entité.
Pour cela, Entity devra fournir un accès mutable à son état cinématique (KineticState).

Remarquez que Gravity n'utilise pas les dimensions de la fenêtre.
Indiquez donc explicitement au compilateur que ce paramètre est intentionnellement inutilisé.

Modifiez la strtucture Entity afin qu'elle puisse posséder un Animator, conformément au diagramme de classes.

Une entité pouvant être animée ou non, cette composition est optionnelle.
En Rust, elle sera représentée par :

Adaptez le constructeur pour initialiser correctement cette nouvelle donnée membre.

Modifiez ensuite la méthode animate().
Elle doit toujours intégrer l'état cinématique de l'entité, puis invoquer la méthode animate() de son Animator si celui-ci est présent.
La taille de la fenêtre devra également être transmise à cette méthode.

Adaptez enfin la fonction create_window() afin qu'elle fournisse un Animator aux entités qui doivent en posséder.
Pour cette première étape, utilisez un objet de type Gravity.

Conflit d'emprunts
Si vous compilez votre programme à ce stade, le compilateur signalera un conflit d'emprunts dans la méthode Entity::animate().

Lors de l'appel à animator.animate(...), l'Animator est emprunté en lecture via self, tandis que l'entité est simultanément empruntée de manière mutable.
Cette situation est interdite, car elle permettrait plusieurs accès simultanés à la même donnée, dont au moins un en écriture.

Pour résoudre ce problème, retirez temporairement l'Animator de l'entité à l'aide de la méthode Option::take().
L'animation pourra alors être exécutée sans conflit d'emprunts.

Une fois l'animation terminée, replacez l'Animator dans l'entité.

À l'issue de cette étape, les entités auxquelles un Gravity est associé doivent être soumises à la pesanteur tout en conservant leur comportement précédent.

Implémentez les nouveaux types d'animations suivants dans le fichier animators.rs.

Friction
Ajoutez une structure Friction possédant un coefficient de friction coef.
Son implémentation de Animator utilisera la méthode friction() de KineticState.

Testez cette animation avec un coefficient égal à 0.1.

Bounce
Ajoutez une structure Bounce possédant un coefficient d'élasticité elasticity.
Cette animation fait rebondir l'entité lorsqu'elle atteint le bord de la fenêtre.
Pour détecter les collisions, utilisez le rayon du cercle englobant de l'entité.
La fonction bounce() fournie par le module kinetics réalise le calcul du rebond ; consultez sa documentation afin d'identifier les paramètres attendus, notamment le vecteur normal au bord rencontré.
Par exemple, si l'entité se heurte contre le bord à gauche, les coordonnées du vecteur normal à ce bord sont 1.0 et 0.0.

Testez cette animation avec un coefficient d'élasticité de 0.75.

Stop
Ajoutez une structure Stop.
Lorsqu'une entité atteint un bord, cette animation l'immobilise tout en la maintenant dans la fenêtre.
Il ne faut pas annuler sa vitesse, seulement replacer l'entité au bord.
Vous aurez besoin du rayon du cercle englobant pour repositionner correctement l'entité.

Pair
Ajoutez une structure Pair permettant de combiner deux objets implémentant Animator.
Cette structure implémente elle-même le trait Animator et délègue simplement l'animation à chacun des deux objets qu'elle contient.

Une fois ces animations validées, modifiez create_window() afin d'associer des animations différentes aux entités.
Par exemple :

Appliquez maintenant la même démarche aux interactions avec la souris.

Déclarez dans simu.rs un trait Interactor contenant une unique méthode click().
Cette méthode reçoit :

Implémentez ensuite une première interaction concrète en créant la structure Turn dans un nouveau fichier interactors.rs.

Cette interaction reproduit le comportement précédemment implémenté dans Entity :

Modifiez la structure Entity afin qu'elle puisse posséder un Interactor.

Comme pour Animator, cette composition est optionnelle.
Ajoutez donc une donnée membre : Adaptez le constructeur pour initialiser cette nouvelle donnée membre.

Modifiez ensuite la méthode click(). Elle doit toujours vérifier que le clic appartient au cercle englobant de l'entité avant de déléguer le traitement à son Interactor, si celui-ci est présent.
Après l'interaction, assurez-vous que l'entité reste dans la fenêtre.

Adaptez également la fonction create_window() afin d'associer un Interactor aux entités qui doivent en posséder.
Pour cette première étape, utilisez un objet de type Turn.

Comme pour Animator, l'appel à click() provoque un conflit d'emprunts.
Résolvez-le en utilisant Option::take() pour retirer temporairement l'Interactor avant de l'invoquer, puis replacez-le dans l'entité une fois l'opération terminée.

À ce stade, l'application doit se comporter exactement comme lors du laboratoire précédent, tout en reposant sur une architecture plus flexible.

Implémentez les nouveaux types d'interactions suivants dans le fichier interactors.rs.

FastForward
Ajoutez une structure FastForward possédant un attribut dt.
Cette interaction avance immédiatement l'état cinématique de l'entité pendant l'intervalle dt en utilisant la méthode integrate() de KineticState.

Testez cette interaction avec dt = 0.5.

Push
Ajoutez une structure Push possédant un attribut speed.
Cette interaction modifie la vitesse de l'entité dans la direction (dx, dy) du clic de souris. x et y indiquent le centre de l'entité.
Le facteur de mise à l'échelle est donné par : factor = speed / bounding_radius.

Testez cette interaction avec speed = 500.0.

Chromo
Ajoutez une structure Chromo.
Cette interaction permute les composantes de la couleur de l'entité selon la transformation : Pour cela, Entity devra fournir un accès mutable à sa couleur.

Pair
Ajoutez une structure Pair permettant de combiner deux objets implémentant Interactor.
Cette structure implémente elle-même le trait Interactor et délègue simplement l'appel à chacun des deux interacteurs qu'elle contient.

Une fois ces interactions validées, modifiez create_window() afin d'associer des comportements variés aux différentes entités.
Par exemple : Vous obtenez ainsi une application capable de combiner indépendamment les formes, les animations et les interactions, sans créer une structure différente pour chaque combinaison possible.