Avant d'ajouter les nouveaux Animator, une difficulté propre à Rust doit être résolue.

Les animations Collide et Repulse devront modifier une entité tout en consultant les autres entités de la fenêtre.
Autrement dit, elles devront accéder simultanément à une entité en modification et à l'ensemble auquel elle appartient.

Une telle situation est difficile à analyser statiquement.
Le borrow-checker ne peut pas garantir à la compilation que deux accès incompatibles ne se produiront jamais, et Rust refuse donc ce type de code.

La solution consiste à reporter cette vérification à l'exécution grâce au mécanisme d'interior mutability (exclusivité dynamique), fourni par le type std::cell::RefCell.

Avec RefCell, les données ne sont accessibles qu'à travers des références partagées.
Lorsqu'un accès est nécessaire, il doit être demandé explicitement :

RefCell vérifie alors à l'exécution que les règles d'emprunt sont respectées.
En cas de conflit, le programme est interrompu par un panic!().

Pour appliquer ce mécanisme, remplacez le type du membre entities de Window par : Adaptez ensuite votre code afin que chaque entité soit stockée dans un RefCell, notamment dans add_entity().

Enfin, remplacez les accès directs aux entités par des appels à borrow() ou borrow_mut(), selon que vous souhaitez les consulter ou les modifier.

Vérifiez que l'application conserve le même comportement qu'au laboratoire précédent.

Les nouveaux Animator devront accéder à l'ensemble des entités de la fenêtre.

Commencez par fournir, dans la structure Window, un accès en lecture à cette collection sous la forme d'une slice.

Déplacez ensuite le contrôle des invariants hors des méthodes Window::animate() et Window::click().
Désormais, une animation ou une interaction peut modifier plusieurs entités : il est donc préférable de vérifier les invariants une seule fois après le traitement de toutes les entités.

Pour cela, ajoutez une méthode adjust() à la structure Window.
Cette méthode parcourt toutes les entités et invoque stay_inside() sur chacune d'elles.

Enfin, adaptez le trait Animator.
Les nouvelles animations ayant besoin d'accéder à toutes les entités, la méthode animate() doit désormais recevoir une référence partagée sur la fenêtre (Window) plutôt que ses seules dimensions.

Mettez à jour les différentes implémentations ainsi que tous les appels à cette méthode.

Vous disposez maintenant de tous les éléments nécessaires pour implémenter les animations Repulse et Collide.

Ajoutez une structure Repulse dans le fichier animators.rs.
Cette structure possède un coefficient de répulsion coef et implémente le trait Animator.

La méthode animate() parcourt toutes les entités de la fenêtre et applique une force de répulsion à chacune d'elles.
Pour chaque entité rencontrée, il faudra :

Consultez le prototype de repulse() afin de déterminer les paramètres attendus.
La distance minimale entre deux entités correspond à la somme de leurs rayons de cercle englobant.

Testez cette animation avec un coefficient de répulsion égal à 100.0.

Ajoutez une structure Collide dans le fichier animators.rs.
Cette structure possède un coefficient d'élasticité elasticity et implémente le trait Animator.

La méthode animate() suit le même principe que celle de Repulse.
La différence est que l'interaction n'a lieu que lorsque la distance entre deux entités est inférieure à la somme de leurs rayons de cercle englobant.

Utilisez pour cela la méthode collide() de KineticState.
Consultez sa documentation afin d'identifier les paramètres attendus.
La masse d'une entité est supposée égal au cube de son rayon.

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