Projet : étape 4.1
Ondes

Buts: Modéliser les ondes émises par les lézards lors de leurs déplacements

Ondes

Nous adopterons le modèle simplifié suivant pour les ondes émises par les lézard :

il s'agira d'ondes circulaires (comme pour le son) dotée d'un vitesse constante v;
le rayon de l'onde au temps t (après début de la propagation de l'onde) sera donné par la formule r(t) = v * t + r₀, où r₀ est le rayon initial de l'onde;
l'énergie de l'onde décroît de manière exponentielle par rapport à la distance de propagation. L'énergie au temps t (après début de la propagation de l'onde) sera donc donné par la formule E(t) = E0 * exp(-r(t)/µ) où µ est une constante caractéristique de l'onde et E0 son énergie initiale;
l'intensité (de l'onde) en un point donné est définie comme étant l'énergie par unité de longueur du front d'onde. Ainsi, l'intensité après un temps t est donnée par la formule :
```
  I(t) = E0 * exp(-r(t)/µ) / (2 * PI * r(t)) = E0 * exp(-(t*v+R0)/µ) / (2 * PI * r(t))
```
(car l'énergie se répartit uniformément sur une cercle de périmètre 2 * PI * r(t))
l'onde peut être fragmentée si elle heurte des obstacles solides lors de sa propagation :

[Video : onde se «brisant» sur des obstacles]

Pour pouvoir dessiner des fragments d'ondes, il est judicieux de stocker ces derniers dans un attribut modélisé comme un ensemble d'arcs; un arc étant caractérisé par un angle de début et un angle de fin. Au départ, il n'y aurait qu'un seul arc dans cet ensemble, allant de -PI à PI. Cet arc pourra ensuite être fragmenté en plusieurs sous-arcs si l'onde croise un obstacle (ce que nous traiterons un peu plus bas). La constante PI est fournie dans le fichier Utility/Constants.hpp.

Il vous est donc demandé maintenant de coder une classe Wave caractérisée par :

le point de départ de l'onde (origine, un Vec2d);
le niveau d'énergie initial et le rayon initial de l'onde (des double);
la constante µ, telle que décrite précédemment (un double);
la vitesse de propagation de l'onde (encore un double);

Des tests de collision avec l'onde (par exemple pour savoir si elle croise un obstacle) devront se faire pendant la simulation. Une onde pourra donc être vue comme un Collider.
Pour être compatible avec les fichiers de test fournis, les attributs seront initialisés par le constructeur dans l'ordre décrit, au moyen de valeurs passées en paramètre.
Vous pouvez coder la classe Wave dans le répertoire Environment/.
Le type prédéfini pair (voir ici) pourra être utilisé pour modéliser les arcs (un arc étant modélisé par une paire d'angles: celui qui caractérise le début et celui qui caractérise la fin de l'arc).

Pour dessiner l'onde, il faudra dessiner les arcs qui la constituent. La méthode buildArc fournie dans Utility[.hpp][cpp] pourra être utilisée. L'épaisseur du trait pourra être proportionnel à l'intensité de l'onde selon un facteur getAppConfig().wave_intensity_thickness_ratio.

Par souci de simplification, l'onde ne sera ni dessinée ni simulée dans un monde torique (vous pouvez le coder en bonus si vous le souhaitez).
Pour le moment, vous ne vous préoccuperez pas de la présence éventuelle d'obtacles dans l'environnement.

[Question Q4.1] Quel liens d'héritage vous semble t-il pertinent d'établir lors du codage de la classe Wave ?

[Question Q4.2] Comment comptabilisez-vous le temps écoulé depuis le début de la propagation de l'onde pour faire évoluer le rayon de celle-ci ? Répondez à ces questions dans votre fichier fichier REPONSES et adaptez votre code en conséquence.

Retouche à la classe `Environment`

Vous considérerez que les ondes appartiennent à l'environnement et ajouterez à la classe Environment une méthode addWave(Wave*).

Une onde dont l'intensité est trop faible (en dessous de getAppConfig().wave_intensity_threshold) doit disparaître de l'environnement.

[Question Q4.3] Quelles retouches devez vous faire à la Environment pour prendre en compte la présence des ondes et les voir se propager et se dessiner ? Répondez à cette question dans votre fichier fichier REPONSES.

Test 23 : propagation d'ondes

Le test fourni WaveTest.cpp que vous pouvez lancer au moyen de la cible waveTest permet de tester la propagation des ondes et leur représentation graphique. Ce test est programmé de sorte à ce qu'un clic gauche avec la souris crée un onde. Cette dernière doit alors se propager selon le modèle de la petite vidéo suivante (redémarrez-là au besoin):

[Video : propagation d'ondes]

Obstacles sur le parcours de l'onde

Il est question maintenant de simuler le fait que l'onde peut se fragmenter sur des obstacles. La mise à jour de l'onde doit donc en plus se préoccuper de l'éventualité d'une collision avec un obstacle. Nous considérerons pour simplifier que tous les obstacles sont des Collider.

Définissez Rock comme une sous classe de Collider représentant un obstacle solide (libre à vous d'étendre cette conception et de coder une hiérarchie d'obstacles solides dont dérivera Rock). Un rocher est un objet dessinable doté d'une orientation (angle). Son constructeur prendra en paramètre sa position (un Vec2d) et tirera au hasard son orientation entre -PI et PI au moyen de la fonction aléatoire uniform (fournie dans Random/Random.[hpp/cpp]). Le rayon d'un Rock sera tiré au hasard entre getAppConfig().simulation_world_size/50 et 2*getAppConfig().simulation_world_size/50, mais vaudra au minimum 1.

La texture rock.png pourra être utilisée pour le dessin. Vous pouvez enrichir vos fichiers de configuration en conséquence (cette texture n'y a pas été incluse). Si vous le faites, il est recommandé que cet ajout soit fait dans app.json (qui est le fichier de configuration par défaut à partir de cette étape), appPPS.json, appTest.json, reprod.json et dans tout autre fichier de configuration que vous auriez créé par vous même. Ainsi ces fichiers de configurations spécifiques demeureront conformes à l'évolution du code dans cette étape du projet.

Modifiez Environment pour la rendre compatible avec la méthode newObstacle de WaveTest (une fois décommentée).

[Question Q4.4] Quelle(s) autre(s) modification(s) devez vous apporter à la classe Environment suite à l'ajout de la méthode newObstacle?

Modifiez ensuite la méthode de mise à jour de Wave de sorte à ce qu'elle intègre aussi la détection de collision avec des obstacles de l'environnement. Une collision est détectée avec un obstacle de l'environnement si ce dernier est en collision avec l'onde ou est à l'intérieur de celle-ci (en tant que Collider). Pour simplifier, on ne tiendra compte que des obstacles dont la position se trouve dans un des arcs de l'onde :

← le second obstacle ne fragmente pas l'onde en plus petits arcs même si un des arcs le touche un peu
(il faut que le centre de l'obstacle soit dans un arc pour qu'il ait effet sur lui)

Pour trouver si l'obstacle se trouve dans un des arcs, arc_i, de l'onde, il suffit de tester que l'angle (obstacle_position - origin).angle(), est contenu dans arc_i (supérieur ou égal au début de arc_i et inférieur ou égal à sa fin). origin est l'origine de l'onde et obstacle_position la position de l'obstacle.

Vous fragmenterez l'arc en vous inspirant des indications du schéma suivant:

← l'angle α qui permet de scinder l'arc bleu en deux arcs rouges
peut se calculer selon la formule 2 * std::atan2(r, R + r)
(le cercle dans la figure représente l'obstacle).
R est le rayon de l'onde et r celui de l'obstacle.

Test 24 : fragmentation d'ondes

Pour tester cette partie, vous pourrez à nouveau utiliser WaveTest.cpp que vous pouvez lancer au moyen de la commande waveTest.

Décommentez au préalable dans ce test la méthode newObstacle ainsi que la gestion du clic droit sur la souris.

Créez plusieurs obstacles et ondes, vous devriez pouvoir observer la fragmentation de vos ondes selon l'exemple suivant:

[Video : propagation d'ondes avec obstacles]

Vous pouvez affiner le modèle en empêchant l'émission d'ondes à partir d'un obstacle.

Lézards émetteurs d'ondes

Un lézard émetteur d'ondes (classe WaveLizard) est une Lizard qui a en plus la particularité d'émettre des ondes toutes les 1.0/getAppConfig().wave_lizard_frequency secondes.

Les ondes émises seront bien sûr générées avec pour origine la position de la lézard et ajoutée à l'environnement.

Les autres caractéristiques de l'onde seront les suivantes :

énergie initiale : getAppConfig().wave_default_energy
rayon initial : getAppConfig().wave_default_radius
µ : getAppConfig().wave_default_mu
vitesse :getAppConfig().wave_default_speed

Vous pouvez coder la classe WaveLizard dans un répertoire Animal/NeuronalScorpion/.

Constructeurs

Pour être compatible avec les fichiers de tests fourni, le WaveLizard aura des constructeurs aux signatures analogues à ceux codés pour Lizard.

Vous veillerez à faire le reste des initialisations qui s'imposent.

Test 25 : lézard émetteur d'ondes

Vous pouvez maintenant commencer à utiliser le programme principal correpondant à l'ensemble de votre projet : FinalApplication.cpp. Ce programme vous permet de tester le nouveau type de lézards ainsi créées.

Les modalités de lancement du test seront les suivantes :

commencer par lancer le test au moyen de la cible application;
basculer ensuite en mode "simulation à l'échelle de l'individu" au moyen de la touche Tab;
mettre la simulation en mode pause au moyen de la barre d'espace;
créer une WaveLizard au moyen de la touche W;
relancer à nouveau la simulation au moyen de la barre d'espace

Vous devriez voir une lézard se déplaçant au hasard en émettant des ondes à une fréquence régulière, tel que le montre la vidéo suivante :

[Video : lézards émetteur d'ondes]

Retour à l'énoncé du projet (partie 4) Module suivant (partie 4.2)

Projet : étape 4.1 Ondes