Mini-projet de Java

Algorithmique-programmation
Master INE CCI - SVS GM
2008-09

Ce mini-projet devra être réalisé individuellement, et rendu au plus tard le 19 décembre 2008 par e-mail à
Bernard.Girau@loria.fr. Vous devrez fournir
Les codes sources .java, commentés.
Un compte-rendu court fournissant les réponses aux questions 1 et 2.5, ainsi qu’une description des tests que
vous aurez effectués pour vérifier votre programme.

Règles du jeu
Ce problème concerne une adaptation libre du jeu de la vie qui a été inventé par Conway en 1970. Le jeu de la
vie se joue ici sur un tableau à 1 dimension. La case i du tableau est soit vide, soit occupée par un poisson. Diverses
espèces de poissons sont considérées (requins, sardines, . . . etc).
Nous nous intéressons à l’évolution, étape par étape, d’une population de poissons rangée dans un tableau de
taille n. Nous supposerons que n > 2. Chaque case appartient à un groupe :
– Le groupe de la case 0 est composé de la case 0 et de la case 1.
– Le groupe d’une case i, avec 0 < i < n − 1, est formé des cases i − 1, i et i + 1.
– Le groupe de la case n − 1 est composé de la case n − 2 et de la case n − 1.
L’évolution d’une case (occupée ou non par un poisson) dépend uniquement du contenu des cases de son groupe à
l’étape précédente. N.B. : un groupe de deux cases se comporte comme si la troisième case était vide.
On sépare les poissons en deux catégories : les prédateurs (requins et murènes) et les proies (sardines et sardinelles).
Certains de ces poissons sont rapides.
Les règles d’évolution de la population des poissons d’une étape à la suivante sont :
Surpopulation Si le groupe de la case i contient trois cases occupées par des poissons de la même espèce, alors le
poisson en case i meurt (sa case devient vide).
Naissance Si la case i est vide, et si son groupe ne contient qu’une seule case non vide, alors la case i se remplit d’un
nouveau poisson, de la même espèce.
Vieillesse Un poisson ne peut pas vivre plus de 5 étapes consécutives.
Faim Un prédateur ne peut pas vivre plus de 2 étapes consécutives sans manger.
Repas Si la case i contient une proie, et si au moins une case de son groupe contient un prédateur, alors le poisson en
case i meurt (sa case devient vide), sauf si la proie en case i est rapide (elle peut s’échapper).
Exemple : évolution d’une population de n = 9 poissons. La lettre ’R’ indique un requin, ’M’ une murène, ’S’ une
sardine, ’s’ une sardinelle, et ’.’ indique une case vide.

0 1 2 3 4 5 6 7 8
Etape 0 : . M S S S R S s S
Etape 1 : M M . . . R . s S
Etape 2 : M M M . R R . s S
Etape 3 : M . M . R R . s S
Etape 4 : . . M . R . . s S
Etape 5 : . M . . . R s s S

1
1 Déroulement du jeu
Expliquez l’évolution des cases 0, 1, 2, 3 et 4 entre les étapes 0 et 1.
Expliquez l’évolution des cases 4, 5, 6, 7 et 8 entre les étapes 4 et 5.
Quel est le contenu du tableau à l’étape 6 ?

Description des classes

Le but de ce projet est de simuler l’évolution d’une population de poissons. Pour cela, une population sera une
instance de la classe JeuVie dont le seul attribut est le tableau dont les cases stockent les poissons.
L’interface Rapide est implantée par toutes les espèces de poissons rapides. Sa déclaration est la suivante :
public i n t e r f a c e Rapide { }

2 Classe Poisson
1. Déclarez la classe Poisson, avec comme attribut d’instance un âge.
2. Déclarez une constante entière limite age égale à 5 (âge limite de vie).
3. Programmez un constructeur vide.
4. Programmez une méthode boolean meurt() qui incrémente l’âge du poisson et indique si le poisson a
atteint l’âge limite.
5. Déclarez la méthode abstraite donneNaissance() qui doit retourner un nouveau poisson de la même espèce
que this. Expliquez pourquoi cette méthode est abstraite.
6. Programmez la méthode évolue avec deux poissons en paramètres. Cette méthode gère l’évolution du poisson
this selon la règle de surpopulation en fonction du groupe de la case qui contient this. Si cette règle entraı̂ne
la mort de this, la méthode évolue lève une exception de type MortException : vous déclarerez cette
classe qui dérive de Exception. N.B. : vous pouvez vous aider de la méthode toString pour connaı̂tre
l’espèce d’un poisson.

3 Classe JeuVie
3.1
Déclarez la classe JeuVie, son unique attribut (tableau de poissons), et un constructeur qui a pour seul paramètre
le nombre n de cases dans le tableau. Le tableau ne contient initialement aucun poisson.

3.2
Les règles du jeu de la vie sont exprimées via la méthode
public static Poisson evolutionGroupe(Poisson p1,Poisson p2,Poisson p3)
qui détermine, pour un groupe de cases occupées par p1, p2 et p3 (références éventuellement égales à null),
quel poisson va occuper la case de p2 après application des règles.
Programmez cette méthode.

3.3
Programmez la méthode void évolution() qui appelle la méthode evolutionGroupe pour tous les
groupes de cases. Attention : tous les groupes évoluent simultanément.

2
4 Espèces de poissons
4.1 Prédateurs
Programmez la classe Predateur en la munissant d’un attribut entier faim, sachant que :
– un prédateur meurt s’il atteint l’âge limite, ou s’il meurt de faim (l’attribut faim étant incrémenté à chaque
évolution de la population).
– la méthode void mange() remet l’attribut faim à 0.

4.2 Proies
Programmez la classe Proie pour qu’elle tienne compte de la règle des repas.

4.3 Espèces
Programmez les classes non abstraites Requin, Murène, Sardine et Sardinelle (sardine très rapide), cha-
cune munie d’un constructeur vide, et d’une méthode toString() qui retourne respectivement "R", "M", "S" et
"s".

4.4 Sauvegarde
Programmez dans la classe JeuVie une méthode void sauve(String nom fichier) qui stocke l’état
courant du jeu dans le fichier texte dont le nom est fourni, sous la forme (pour l’exemple à l’étape 5)
n=9
.M...RssS