Simulation de Nuées

Introduction

L'application fournit une architecture pour faire des simulations de "bébêtes". Ces bébêtes évoluent dans un espace clos, le simulateur doit permettre de voir leurs déplacements. Une bébête a donc une position, elle se déplace dans une certaine direction avec une vitesse donnée et elle peut voir devant elle avec un certain champ de vision. Elle est censée agir en fonction de son environnement (les bébêtes aux alentours). Vous disposez d’une version de base du projet (code source) et d’un jar permettant d’essayer le résultat final. Vous disposez de deux séances pour réaliser ce tp. A la fin de la première séance, vous devriez être dans la partie IV sur la fabrique de fabriques.

Pour conserver l’évolution du tp, vous pouvez faire pour chaque partie un projet différent dans votre IDE préféré.

Partie I - Prise en main des bébêtes

 Temps estimé: 40 minutes

Vous disposez d’un code de départ qui contient un projet Eclipse:

• Sous Eclipse, File/Import...
• Select Existing projects into workspace..., Next
• Select Archive File and browse to select the .zip file
• Select "Bebets 01 Debut" and Finish 

Essayons de mettre à plat ensemble les entités simulées à partir du code que nous avons au départ. On peut déjà distinguer un certain nombre de rôles différents dans une bébête:  

• c'est une entité graphique qui se dessine avec une certaine couleur ;  
• c'est une entité qui a une certaine position dans un champ ;  
• c'est une entité qui se déplace et se dirige (vitesse et direction), on distinguera position et déplacement, car on pourrait vouloir mettre des entités positionnées mais inertes dans notre simulateur ;  
•  c'est une entité qui agit, ou tout du moins qui s'actionne, puisque c'est le "moteur de simulation" qui la fait agir...  

Un champ de bébêtes est l’entité qui « porte » les bébêtes :  

• un champ possède une certaine dimension ;
• un champ contient des entités positionnables  ;
• il y a un moteur de simulation avec un thread qui provoque des pas de simulation et actionne les objets "actionnables" à chaque pas ; 

il y a aussi un moteur d'affichage, plutôt mal fichu, car entièrement couplé avec le moteur de simulation à coup de méthode repaint, alors qu'il serait beaucoup mieux d'avoir un second moteur (donc un second thread) pour la visualisation, indépendamment de la simulation

NB: ne perdez pas de temps avec les méthodes utilitaires de calcul de direction et de distance, qui sont dans une classe utilitaire. 
Ne perdez pas de temps avec la classe de lancement de programme « bebetes.LanceBebetes ». 
Ne prenez pas en considération (pour l’instant) les tests unitaires.

Les étapes suivantes apporteront des réponses basées sur les patrons de conception, afin de rendre le code plus évolutif (meilleure structuration du code).

Partie II - Patron de structure: décorateur

  Temps estimé: 60 minutes

Pour répondre à la Question 3, puisqu’il s’agit d’ajouts non fonctionnels, et plutôt que de faire beaucoup d’héritage (nombre de décorations x nombre de types de bébêtes), vous allez appliquer le patron Décorateur. Procéder en cinq étapes : 

Partie III - Patron de création: Usine/Fabrique

   Temps estimé: 40 minutes

Partie IV - Fabrique de Fabriques

Temps estimé: 40 minutes

En pratique, le champs de bébêtes n'a pas besoin de connaître l'usine concrète qui est utilisée. Il devrait également être possible de changer d’écosystème en cours d’exécution et de régénérer la liste des bébêtes. Pour cela il faut utiliser une fabrique de fabriques.

Une fabrique de fabriques est une classe (EcosystemFactory) qui possède une méthode getEcosystem pour créer une BebeteFactory. L'utilisateur ne connaît pas la classe concrète utilisée. Le critère de construction de la fabrique peut être arbitraire (Random) ou peut dépendre d'un paramètre de la méthode getEcosystem.

Partie V - Patron de comportement : Stratégie

Temps estimé: 60 minutes

Partons de l'hypothèse qu’une bébête BebeteEmergente pourrait avoir « un accident » et se comporter dès lors comme une bébête BebeteHasard. A l’inverse, les hasards de l’évolution peuvent créer quelques bébêtes BebeteHasard avec un comportement grégaire. Ainsi le comportement coder en dur dans les classes BebeteHasard et BebeteEmergente pourrait être changé : (i) à la création d’une bébête et/ou (ii) à l’exécution. L’objectif est donc d’encapsuler le comportement, le sortir de la classe Bebete et l’abstraire pour pouvoir en proposer des implantations différentes. Il s’agit là du patron de comportement Strategie. 

Voici l’abstraction proposée : 

package bebetes.strategy;

import bebetes.Bebete;

public interface Strategy {
  public void calcule(Bebete bebete);

  public void applique(Bebete bebete);
 }

Partie VI - Patron de structure : Adaptateur

 Temps estimé: 60 minutes

Votre projet a connu une branche il y a quelques temps. Et une autre personne a développé des stratégies autrement. Cette branche contient quelques erreurs de conceptions et arrive à un cul de sac, notamment car la simulation n’est pas très bien gérée. Cependant elle contient une stratégie qui vous intéresse : la Fuite. Vous ne voulez pas tout recoder, alors vous allez devoir adapter ce qui a été fait à votre projet. Vous disposez d’un jar (qui inclue une javadoc minimale) de la branche différente : versionparallele.jar .
(configurez votre IDE pour que cette javadoc soit accessible, dans eclipse c’est dans « Project > Properties > Java Build Path > Libraries ) 

La classe culdesac.Fuite hérite de culdesac.Comportement (classe qui définit la « stratégie »). Cependant, elle n’a qu’une seule méthode :  

/**
 * en param : il faut la liste des voisins et qui on est
 * agit calcule l'état à  l'instant suivant (x, y, vitesse, orientation)
 * il faut donc renvoyer ses quatre valeurs sous forme d'un Etat
 * Limitation/Défaut de conception : appel non maitrisé, il faut que params soit : distanceMin, vitesseMax, Class de filtrage 
 * @param list liste des bebetes autour (type culdesac.MaBebete)
 * @param etatCourant position, vitesse et direction (culdesac.Etat) de la
 * @param params appel non maitrisé, il faut que params soit : distanceMin, vitesseMax, Class de filtrage
 * @return le futur état (position, vitesse et direction )
 */
public Etat agit(ArrayList<MaBebete> list, Etat etatCourant, Object... params)

La classe culdesac.Fuite n’utilise que le second param (params[1]) comme vitesse maximum à ne pas dépasser (lors de la fuite). 

Les bébêtes sont des instances (via des classes concrètes) de la classe abstraite culdesac.MaBebete. La position actuelle et celle future sont stockées dans une classe « structure » culdesac.Etat :

package culdesac;

public class Etat {
  public Etat() { }

  public Etat(Etat toClone) {
    x = toClone.x;
    y = toClone.y;
    vitesse = toClone.vitesse;
    direction = toClone.direction;
  }

  public double x, y;

  public double vitesse, direction;
} 

Précisons également que les classes culdesac.ChampDeBebetes et bebetes.ChampDeBebetes sont différentes.