On vous fournit un programme tortues2.py,
qui contient une classe Tortue définie à partir de la
classe Pen. Etudiez-en la définition, dessinez la classe correspondante
en UML (nom, attributs, méthodes), assurez-vous que vous en comprenez
les méthodes et le fonctionnement en créant un programme qui
permet de les tester.
Vous allez maintenant créer un nouvelle classe de tortues, qui spécialise
la classe Pen, appelée TortueAmie, sachant que :
- à sa création, une TortueAmie possède une
certaine direction et une certaine couleur (*).
- une TortueAmie peut connaitre une autre TortueAmie et être
capable d'interagir avec elle.
- on peut demander à une TortueAmie son nom et la distance
à laquelle elle est d'une autre tortue (méthode distance,
pour laquelle on pourra utiliser la fonction hypot
du module math).
- on peut donner la main à une TortueAmie (méthode
donneMain).
- lorsqu'une tortue à la main, elle accomplit une tâche (méthode
tache, par exemple se déplacer
d'un certaine distance, puis tourner d'un certain angle (*) ), puis passe
la main à la tortue qu'elle connait, si celle-ci n'est pas trop loin.
Si elle n'en connait pas ou que l'autre tortue est trop loin, elle rend
la main.
Dessinez la classe TortueAmie en UML. Programmez-la.
Pour tester la classe, vous allez créer une liste de n tortues actives,
qui se connaissent mutuellement. Le programme principal leur passera tour
à tour la main, les tortues se passant la main entre elles si elles
ne sont pas trop éloignées les unes des autres.
Tester ce programme avec différentes variantes de distances, de déplacements,
de changements d'angles, de passage de main, etc. Le programme principal peut
décider que toute tortue trop éloignée du point de départ
doit être détruite et supprimée de la liste. Vous pouvez
aussi décider que les tortues en connaissent plusieurs, voire qu'elles
se connaissent toutes, etc.
(*) on pourra utiliser la fonction randrange
du module random.
On vous fournit le diagramme de classe suivant, qui comprend une classe Arbitre,
lequel dirige une équipe de tortues. Les tortues ont un comportement
commun, qui se manifeste dans la classe Tortue, mais ont un comportement
qui peut varier (par exemple, on a deux équipes, les tortue vertes
et les tortues bleues, dont les déplacements ne sont pas les mêmes,
et qui n'ont pas même couleur). Chaque tortue peut posséder le
Ballon (qui est également une sous-classe de Pen, capable de
se dessiner comme un petit cercle rouge) et le passer à une
autre.
Le jeu se déroule de la façon suivante. On crée un objet
arbitre, auquel on demande de créer le jeu (ie. de créer
une liste de tortues vertes et bleues, ainsi qu'un objet ballon, qui sera
affecté à une des tortues). Ensuite on demande à l'arbitre
de lancer le jeu. Pour cela, l'arbitre passe la main à chaque tortue
successivement (deplacer). A chaque fois qu'une tortue doit se déplacer,
elle effectue le déplacement, puis, si elle a le ballon, le dessine,
puis se pose la question de faire une passe. Pour cela, elle demande à
l'arbitre la liste des tortues les plus proches (à moins d'une certaine
distance), classées par distance. Si une tortue de sa couleur est la
plus proche, la tortue se débarrasse du ballon, qu'elle lui passe (auquel
cas la tortue qui récupère le ballon devra lui demander de se dessiner).
Si la tortue la plus proche est de l'autre équipe, alors il y a un
certain pourcentage de chance pour que la balle soit subtilisée). On
continue jusqu'à ce que le ballon soit passé ou la liste des
voisins épuisées.
Codez ces diverses classes, testez-en le bon fonctionnement.
Rendu :
- rapport expliquant le fonctionnement choisi, contenant obligatoirement
le diagramme de classe final correspondant aux choix effectivement réalisés,
le mode d'emploi, toute remarques utiles
- le code du projet.