Partie 1 : Modélisation UML
Question 1.1 (1 pt)
Quel est le type d’association entre la classe Jeu et la classe Chambre. Rappelez sa définition. Traduisez
cette association en une simple composition.
Question 1.2 (1 pt)
Sachant qu’on veut maximiser l’utilisation de la composition, quelqu’un affirme que l’utilisation de la
composition est incorrecte dans le modèle UML proposé par le développeur. Pensez-vous qu’il a raison ?
Pour chaque composition, justifiez votre réponse et éventuellement corrigez.
Question 1.3 (1 pt)
Elaborez le diagramme d’objets relatif au diagramme de classes proposé par le développeur et
représentant le jeu présenté dans la première figure (avec seulement 1 jeu, un soldat, 3 ennemis, 3 armes et des
chambres). Prenez les conventions suivantes : la position 0,0 correspond au coin haut gauche de la grille,
les colonnes positives à droite, les lignes positives en bas.
Question 1.4 (2 pts)
On suppose que le soldat lors de son premier déplacement a récupéré le fusil le plus proche de lui
comportant 10 balles, s’est rendu dans la chambre occupée par deux ennemis de type ‘Kattel’ et a fait 5
attaques.
a) Elaborez le diagramme d’objets relatif à cette situation et avant les attaques.
b) Sachant que la mise à jour des occupants se fait après l’attaque, représentez la nouvelle version du
diagramme objets après les 5 attaques
Question 1.5 (1 pts)
Afin qu’un ennemi puisse naviguer vers les chambres qui contiennent au moins un ennemi, de petites
modifications s’avèrent nécessaires. Sachant qu’on ne veut apporter aucun nouveau lien avec la classe Jeu,
proposez les changements nécessaires au modèle UML. N’oubliez pas d’expliquer votre solution. (Il est
conseillé de représenter que les classes concernées par le changement).
Partie 2 : Codage C++
Question 2.1 (0,5 + 1 pt)
Publicité
L’implémentation des associations avec cardinalité multiple nécessite l’utilisation d’une structure qui
implémente une collection (non définie dans le modèle UML proposé par le développeur).
a) A partir de l’énoncé, dégagez les règles de gestion relatives aux différentes associations multiples.
b) Sachant qu’on souhaite utiliser les collections STL et qu’on souhaite avoir deux collections distinctes
une pour les ennemis et une autre pour les armes, proposez les différentes structures que vous comptez
utiliser pour les différentes associations multiples. Commentez brièvement vos choix.
Question 2.2 ( 3 pts)
Conformément à vos choix établis dans les questions précédentes, donnez la déclaration et
l’implémentation de la classe Chambre. Il est conseillé de donner l’implémentation de toutes les méthodes
avec leur déclaration.
Question 2.3 (2 pts)
Pour cette question, nous supposons que les méthodes fuir() et attaquer() ne font qu’afficher un message,
mais il est évident qu’ils ont une mission plus complexe que l’affichage. Dans l’implémentation de la
méthode attaquer, un développeur a proposé une partie du code suivant relative à une contre attaque d’un
ennemi :
Soldat::attaquer() {
...
if (a->get_type() == "Fusil" && e->get_type() == "Balbaz") e->fuir();
else if (a->get_type() == "Fusil" && e->get_type() == "Kattel") e->attaquer();
if (a->get_type() == "Bombe" && e->get_type() == "Balbaz") e->attaquer();
else if (a->get_type() == "Bombe" && e->get_type() == "Kattel") e->fuir();
}
1/2
Sachant que :
- a est un objet dynamique sur l’arme
détenu par le soldat
- e est l’objet dynamique ennemi qui
Publicité
est attaqué
class Arme {
public:
string get_type() const {return "Arme";}
...
};
class Fusil : public Arme {
public:
string get_type() const {return "Fusil";}
...
};
class Bombe: public Arme {
public:
string get_type() const {return "Bombe";}
...
};
class Ennemi {
public:
string get_type() const{return "Ennemi";}
void attaquer(){cout << "Enm - attaque\n";}
void fuir(){cout << "Enm - fuit\n";}
...
};
class Kattel : public Ennemi {
public:
string get_type() const {return "Kattel";}
void attaquer(){cout << "Ktl attaque\n";}
Publicité
void fuir(){cout << "Ktl - fuit\n";}
...
};
class Balbaz : public Ennemi {
public:
string get_type() const {return "Balbaz";}
void attaquer(){cout << "Blz - attaque\n";}
void fuir(){cout << "Blz - fuit\n";}
...
};
a) Expliquez pourquoi cette partie de code ne fonctionne pas :
b) Sachant que l’attribut type de la classe Occupant est {frozen} et qu’on ne veut plus redéfinir la
les attributs et
méthode Occupant::get_type() dans ses classes dérivées, donner
l’implémentation de tous les constructeurs des classes Occupant, Ennemi, Kattel, Balbaz, Arme, et
Fusil. N’oubliez pas de respecter vos réponses à la question 1.5.
Question 2.4 (2,5 pts)
Il s’agit maintenant de faire les modifications nécessaires aux méthodes de la hiérarchie de classes occupant
afin d’assurer les traitements de la contre-attaque ainsi que de la fuite des ennemis et de mieux profiter du
polymorphisme. Nous vous suggérons d’ajouter aux ennemis une méthode reagir() qui prend en paramètre
une arme. Après vos modifications, la partie du code relative à la contre-attaque d’un ennemi ne doit pas être
comme dans la solution proposée par le développeur dans la question 2.3 mais devrait ressembler à ceci :
e->reagir(a);
Donner la déclaration et l’implémentation de toutes les méthodes de la hiérarchie de classes Occupant. On
suppose que la fuite d’un Balbaz se fait dans la chambre qui contient le maximum de balles. Alors que la
fuite d’un Kattel se fait dans la chambre la moins peuplé d’ennemis.
Question 2.5 ( 3 pts)
Publicité
Donnez la déclaration de la classe Jeu ainsi que l’implémentation de toutes les méthodes sauf les méthodes
afficher() et gagnant(). On suppose que le placement des occupants se fait dans le constructeur et
conformément à la configuration de l’énoncé du jeu.
Question 2.6 (2 pts)
Le déplacement du soldat à l’intérieur de la grille est assuré par la méthode commanditer qui fait appel à la
méthode deplacer en lui communiquant le sens de déplacement ainsi que la dimension de la grille. Dans le
cas où le sens de déplacement choisi fait sortir le soldat de la grille, une exception est lancée au niveau de la
méthode deplacer et un déplacement dans le sens contraire est effectué. En vous appuyant sur
l’implémentation incomplète présentée ci-dessous, donnez l’implémentation de la classe Debordement ainsi
que celle des méthodes deplacer et corriger.
enum sens {haut, bas, gauche, droite} ;
void Jeu::commanditer (string nom) {
...
try{
matrix.deplacer(d,n);
}
catch(Debordement &e){
e.corriger();
}
...
}
2/2