Le labo précédent nous a montré comment doter les entités graphiques de formes variées.
Étant donné que ce n'est que la forme qui peut varier, nous avons choisi de rendre polymorphe seulement le comportement d’une forme graphique (son dessin et le calcule du rayon de son cercle englobant).
Pour rappel : choisir de ne rendre que le comportement polymorphe, est la conclusion à laquelle les experts sont arrivés après plusieurs années d'utilisation du paradigme orienté objet.

Nous avons atteint cet objectif, en introduisant l'interface (trait en Rust) Shape, et de doter l'entité d'une forme variable à travers une composition à un composant avec le type Shape.
Ensuite, cette composition se concrétise en donnant à toute entité un objet de n’importe quel type qui implémente le trait Shape et qui, en conséquence, assure le dessin et le calcule du rayon du cercle englobant.

Répétons alors encore et encore cette démarche pour qu'elle devienne systématique.
Nous ferons cela dans le but d’obtenir une variété d’animations et d’interactions que les entités pourront avoir : les objets graphiques pourront alors être soumis à la force de gravité ou rebondir contre les bords de la fenêtre ou les traverser, il pourront changer de direction en conséquence au clic de la souris, ou s’arrêter, ou changer de couleur…

Généralisez la démarche pour obtenir une variété d'animations.
Commencez par déclarer une nouvelle interface (trait en Rust) dans le fichier simu.rs.
Ce trait doit s’appeler Animator et ne contenir qu’une seule fonction abstraite animate().
La fonction ne renvoie rien et a besoin de recevoir en paramètre une référence exclusive (mutable)✍ sur l'entité à animer, une référence partagée (non-mutable) sur les dimensions de la fenêtre à laquelle l'entité appartient et l'intervalle de temps dt.
Pour rappel : la fonction animate() est une fonction membre et comme toute méthode, elle doit recevoir aussi le self.

Comme pour le trait Shape, l’implémentation de la fonction animate() du trait Animator ne pourra être fournie que par les types implémentant le trait.
Ajoutons alors un premier de tels types.

Déclarez une classe Gravity dans un fichier animators.rs (ce fichier fournira toutes les types d’animations possibles pour les entités).
Cette structure n’a besoin d’aucune donnée membre et son bloc impl doit fournir un constructeur new() très banal.
Ensuite, il faut fournir une implémentation du trait Animator pour le type Gravity.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite animate() : elle modifie la composante y de la vitesse de l’entité en lui ajoutant 10.0 * 9.81 * dt (sans le facteur 10.0, l’animation serait trop lente et on ne verrait pas grand-chose).
Remarquez que dans l’état actuel, l’entité ne donne pas accès en modification à sa donnée membre kinetics de type s5::KineticState.
Faites en sorte que cela soit possible.
Remarquez aussi, que pour le type Gravity, la taille de la fenêtre à laquelle l’entité appartient n’est pas nécessaire.
Il faudra alors dire explicitement au compilateur de ne pas tenir compte de ce paramètre dans la fonction animate().

Modifiez la classe Entity pour qu'elle soit liée par composition à 0..1 composants avec la nouvelle interface.
Nous choisissons une composition à 0..1 composants pour permettre à une entité d'avoir (ou pas) un Animator.
Sans Animator l’entité se contentera d’avoir une animation de base qui consiste à intégrer la position de l’entité même pendant dt.
En Rust, une composition à 0..1 s’obtient en utilisant un Option<T>.
En particulier, dans notre cas, le type de la donnée membre sera : Option<Box<dyn Animator>>>.
Appelez cette donnée animator :

Adaptez le constructeur pour initialiser correctement la nouvelle donnée membre de la classe Entity.

Adaptez la fonction animate() : elle doit toujours imposer integrate() mais doit aussi invoquer la fonction animate() de son Animator si elle en possède un.
Remarquez que maintenant cette fonction doit recevoir aussi la taille de la fenêtre d’appartenance pour la passer ensuite à la fonction animate() de son Animator.

Dans l’état actuel, le code présente des erreurs… en effet, le constructeur de la classe Entity a changé et la façon d’instancier des objets de ce type dans la fonction populate_window() du fichier lib.rs n’est plus correcte.
Il faudra, notamment, passer au constructeur un pointer intelligent Box pointant sur un objet dont le type implémente le trait Animator.

Pour cela, avant toute instanciation d’une entité, déclarez un Box<dyn Animator> pour qu’il pointe sur un objet de type Gravity (qui, pour le moment, est le seul type concret implémentant le trait Animator).
Passez ce pointeur au constructeur du type Entity.
Attention ! Rappelez-vous que l’Animator est optionnel !

Même si vous avez suivi les instructions à la lettre et implémenté tout le code demandé, vous tomberez quand même sur une erreur.
Vous verrez que le compilateur vous informe que, dans la fonction animate() d’Entity, vous essayez d’accéder à la même donnée (l’objet courant : self) à la fois de façon partagée et mutable.
Pour comprendre le problème, considérez le dessin suivant, où la boîte à gauche représente un objet de type Entity avec ses données membres et à gauche le prototype de la fonction animate() de l’Animator.

Lorsque la fonction animate() de l’Animator est invoquée par une entité, la référence self pointera en seule lecture sur l’animator courant appartenant à l’entité et le paramètre entity référencera en modification l’entité même.
Or, à travers la référence entity nous pourrions accéder à l’animator qui est déjà consulté à travers la référence self.
Cette situation, en Rust, est interdite.
Nous ne pouvons pas écrire un code qui permet plusieurs accès simultanés sur une donnée si un de ces accès est mutable.
En d’autres mots : on ne peut pas accéder à quelque chose qui est en cours de modification.
La cohérence des données ne serait pas garantie.

D’autres langages moins stricts que Rust peuvent permettre une telle situation, mais au même temps, contrairement à Rust, ils ne garantissent pas l’intégrité des données.

Pour résoudre ce problème, la solution consiste à déplacer temporairement l’animator dans une variable locale à l’aide de la fonction take() fournie par le type Option<T>.
L’animator sera alors extrait de l’objet de type Entity et l’invocation de la fonction animate() ne causera plus aucun conflit.

Évidemment, une fois l’invocation de la fonction animate() terminée, il faudra rendre l’animator à l’entité, toujours en se rappelant qu’il s’agit d’une donnée optionnelle.

Si votre code est correct, le lancement de l’application montrera une fenêtre graphique contenant 8 cercles et 8 rectangles tous soumis à l’apesanteur.
Ces objets graphiques restent toujours visibles et réagissent au clic.

Déclarez une classe Friction dans le fichier animators.rs.
Cette classe a besoin d’une donnée membre réelle coef qui représente le coefficient de friction.
Son bloc impl doit fournir un constructeur.
Ensuite, il faut implémenter le trait Animator pour le type Friction.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite animate() : elle invoque la fonction friction fournie par le type s5::KineticState.
Pour savoir comment invoquer cette fonction, lisez attentivement son prototype.
Testez ce nouvel Animator en utilisant 0.1 comme coefficient de friction.

Déclarez une classe Bounce dans le fichier animators.rs.
Cette classe a besoin d’une donnée membre réelle elasticity qui représente le coefficient d’élasticité.
Son bloc impl doit fournir un constructeur.
Ensuite, il faut implémenter le trait Animator pour le type Bounce.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite animate().
Cette fonction doit faire rebondir l'entité contre le bord de la fenêtre d'appartenance.
Pour cela, elle doit détecter si un bord a été touché (vous aurez besoin de connaître le bounding_radius de l’entité). Si cela est le cas, servez-vous de la fonction globale bounce() fournie par le module kinetics pour faire rebondir l'entité.
Pour savoir comment invoquer la fonction bounce(), lisez attentivement son prototype.
Vous remarquerez que cette fonction a besoin entre autres des coordonnées du vecteur normal au bord.
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.
Déduisez les autres et, enfin, testez ce nouvel Animator en utilisant 0.75 comme coefficient d’élesticité.

Déclarez une classe Stop dans un fichier animators.rs.
Cette classe n’a besoin d’aucune donnée membre et son bloc impl doit fournir un constructeur très banal.
Ensuite, fournissez une implémentation du trait Animator pour le type Stop.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite animate() : elle doit faire arrêter l’entité au bord de la fenêtre dès qu’elle le touche.
Il faudra s’assurer que dès que l’entité dépasse un bord elle soit replacée dans la fenêtre à côté du bord.
Pour cela, il faudra consulter le bounding_radius de l’entité.
Testez ce nouvel Animator.

Déclarez une classe Pair dans le fichier animators.rs.
Cette classe permet d’enchaîner deux animators et doit implémenter l'interface Animator, de cette façon nous pourrons doter une entité de tous les animators que nous voudrons.
La classe doit contenir deux pointeurs dynamiques de type Animator, first et second. Ils seront initialisés dans le constructeur.
Ensuite, il faut fournir une implémentation du trait Animator pour le type Pair.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite animate() : elle ne fera rien d'autre qu'appeler en séquence les fonctions animate() des deux Animator que la classe contient.
Cela permettra d'obtenir des entités avec 2 animations, qui peuvent par exemple rebondir contre les bords et se repousser ou qui subissent une friction et la pesanteur.
Testez ce nouvel Animator.

Maintenant que vous êtes sûrs que vos animators fonctionnent comme voulu, modifiez la fonction populate_window() du fichier lib.rs, pour combiner formes et animations différentes.
Par exemple, dotez toutes les formes pleines d'un animator de type Pair, contenant un animator Gravity et un animator Bounce dont le coefficient d'elasticité est 0.75.
Ensuite, dotez toutes les formes vides d'un animator Stop.

Répétons encore une fois la démarche suivie à partir de l’étape 1 pour obtenir, cette fois, une variété d’interactions.
Commencez par déclarer une nouvelle interface (trait en Rust) dans le fichier simu.rs.
Ce trait doit s’appeler Interactor et ne contenir qu’une seule fonction abstraite click().
La fonction ne renvoie rien et a besoin de recevoir en paramètre une référence exclusive (mutable) sur l'entité qui subit le clic de la souris, une référence partagée (non-mutable) sur la position en 2D de la souris (utiliser le type s5::Point).
Pour rappel : la fonction click() est une fonction membre et comme toute méthode, elle doit recevoir aussi le self.

Comme pour les traits Shape et Animator, l’implémentation de la fonction click() du trait Interactor ne pourra être fournie que par les types implémentant le trait.
Ajoutons alors un premier de tels types.

Déclarez une classe Turn dans un fichier interactors.rs (ce fichier fournira toutes les types d’interactions possibles pour les entités).
Cette structure n’a besoin d’aucune donnée membre et son bloc impl doit fournir un constructeur très banal.
Ensuite, il faut fournir une implémentation du trait Interactor pour le type Turn.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite click() : elle modifie la vitesse de l’entité comme suit :

Modifiez la classe Entity pour qu'elle soit liée par composition à 0..1 composants avec la nouvelle interface.
Nous choisissons une composition à 0..1 composants pour permettre à une entité de réagir (ou pas) au clic de la souris.
Pour rappel, en Rust, une composition à 0..1 s’obtient en utilisant un Option<T>.
Appelez cette donnée interactor.

Adaptez le constructeur pour initialiser correctement la nouvelle donnée membre de la classe Entity.

Adaptez la fonction click() : elle doit toujours s’assurer que le clic de la souris soit dans le cercle englobant de l’entité avant d’invoquer la fonction click() de son Interactor si elle en possède un.
Si l’entité ne possède pas d’Interactor, il ne se passera simplement rien.
Attention ! Rappelez-vous que pour éviter d’accéder à la même donnée (l’objet courant : self) à la fois de façon partagée et mutable, nous devons d’abord déplacer l’interactor dans un variable locale (à l’aide de la fonction take() du type Option), puis invoquer la fonction click() et enfin rendre l’interactor à l’entité.
Assurez-vous que l’entité reste bien dans la fenêtre après avoir été cliquée (invoquez la fonction stay_inside()).

Dans l’état actuel, le code présente encore des erreurs… en effet, le constructeur de la classe Entity a changé et la façon d’instancier des objets de ce type dans la fonction populate_window() du fichier lib.rs n’est plus correcte.
Il faudra, notamment, passer au constructeur un smart pointer Box pointant sur un objet dont le type implémente le trait Interactor.

Pour cela, avant tout instanciation d’une entité, déclarez un Box<dyn Interactor> pour qu’il pointe sur un objet de type Turn (qui, pour le moment, est le seul type concret implémentant le trait Interactor).
Passez ce pointeur au constructeur du type Entity.
Attention ! Rappelez-vous que l’Interactor est optionnel !

En testant l’application, vous remarquerez qu’elle se comporte exactement comme avant et que les 16 objets graphiques répondent toujours de la même façon au clic de la souris.
Ajoutons alors d’autres types concrets implémentant le trait Interactor pour obtenir des interactions variées.

Déclarez une classe FastForward dans un fichier interactors.rs.
Cette classe a une seule donnée membre réelle dt. Son bloc impl doit fournir un constructeur.
Ensuite, il faut fournir une implémentation du trait Interactor pour le type FastForward.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite click() : elle doit intégrer l’état cinématique de l’entité pendant dt.
Utilisez la fonction integrate() fournie par le type s5::KineticState.
Testez ce nouvel Interactor en utilisant 0.5 pour initialiser le membre dt.

Déclarez une classe Push dans un fichier interactors.rs.
Cette classe a une seule donnée membre réelle speed. Son bloc impl doit fournir un constructeur.
Ensuite, il faut fournir une implémentation du trait Interactor pour le type Push.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite click() : elle doit changer la vitesse de l’entité dans la direction de la souris✍ et cette vitesse doit être égale à l'écart entre le centre de l'entité et la position du clic de la souris, multipliés par le facteur suivant : Testez ce nouvel Interactor en utilisant 500.0 pour initialiser le membre speed.

Déclarez une classe Chromo dans un fichier interactors.rs.
Cette classe n’a besoin d’aucune donnée membre et son bloc impl doit fournir un constructeur très banal.
Ensuite, il faut fournir une implémentation du trait Interactor pour le type Chromo.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite click() : elle doit modifier la couleur de l’entité comme suit : (r, g, b) → (g, b, r).
Cela veut dire que la valeur de la composante verte doit devenir la valeur de la composante rouge et ainsi de suite.
Évidemment, il faut que la classe Entity fournisse une fonction qui renvoie une référence exclusive (mutable) sur sa couleur afin de pouvoir la modifier.
Testez ce nouvel Interactor.

Déclarez une classe Pair dans le fichier interactors.rs.
Cette classe permet d’enchaîner deux interactors et doit implémenter l'interface Interactor, de cette façon nous pourrons doter une entité de tous les interactors que nous voudrons.
La classe doit contenir deux pointeurs dynamiques de type Interactor, first et second. Ils seront initialisés dans le constructeur.
Ensuite, il faut fournir une implémentation du trait Interactor pour le type Pair.
Dans ce deuxième bloc impl, vous devez définir la fonction abstraite click() : elle ne fera rien d'autre qu'appeler en séquence les fonctions click() des deux Interactor que la classe contient. Cela permettra d'obtenir des entités avec 2 façons d’interagir, qui peuvent par exemple changer de vitesse et de couleur.
Testez ce nouvel Interactor.

Maintenant que vous êtes sûrs que vos interactors fonctionnent comme voulu, modifiez la fonction populate_window() du fichier lib.rs, pour combiner formes, interactions et animations différentes.
Par exemple, dotez toutes les formes pleines d'un interactor de type Pair, contenant un interactor Chromo et un interactor Push dont la vitesse est 500.0.
Ensuite, dotez toutes les formes vides d'un interactor de type Pair, contenant un interactor Turn et un interactor FastForward qui doit recevoir la valeur de 0.5 pour initialiser son membre dt.

Vous avez obtenu un code capable de créer des formes variées, toujours visibles, qui se déplacent et réagissent au clic de la souris de différentes manières.
Vous n'avez pas eu besoin d'inventer un nouveau type d'entité pour chaque combinaison de forme, animator et interacteur (ce qui aurait engendré une explosion combinatoire) ; la composition de quelques types abstraits de données suffit à obtenir une très grande variété d'entités.