besoin d'aide c'est le corps de l’énoncé
Problème : Labyrinthe
On se propose d’implémenter un jeu de labyrinthe simplifié mettant en opposition un héros et
plusieurs monstres qui sont dans les couloirs d’un labyrinthe. Dans le cadre de ce problème, un
labyrinthe est une série de chambres adjacentes. C’est ainsi, qu’un labyrinthe n’a pas nécessairement
une forme rectangulaire de n lignes et m colonnes. Il est à noter qu’on peut avoir plusieurs formes
possibles de labyrinthe.
Une chambre contient toujours 4 portes. Une porte peut être verrouillée ou non. Donc, il
peut arriver que les 4 portes d’une chambre soient verrouillées. On suppose que toutes les portes qui
se trouvent à la frontière du labyrinthe sont verrouillées. Entre 2 chambres adjacentes, il y a donc 2
portes distinctes unidirectionnelles pour un même mur, mais seulement la porte appartenant à la
chambre courante peut être utilisée. La chambre qui contient initialement le héros est désignée par
chambre d’entrée. Il convient de mentionner que les couloirs se construisent grâce au placement de
portes verrouillées sur les différents côtés des chambres et qu’on peut trouver une suite de
chambres ne contenant pas les sorties et dont toutes les portes sont verrouillées que nous désignons
par trappe.
Ainsi, la sortie se trouve dans une des chambres du labyrinthe (l’héros doit la trouver). Pour y
arriver, lorsque le joueur se déplace, il obtient à l’écran des informations relatives à l’emplacement
de la chambre de sortie, pour l’aider à s’orienter.
L’héros est toujours dans une chambre du labyrinthe. Il se déplace dans le labyrinthe dans le
but d’en sortir vivant ! Le déplacement de l’héros est commandité par un joueur moyennant les
quatre commandes tapées au clavier (nord, est, sud et ouest) qui lui permettent de se déplacer à
l’intérieur des couloirs et ce sur l’une des quatre chambres franchissables voisines à la sienne (nord,
est, sud et ouest). Le héros a un nom et sait dans quelle chambre il se trouve.
Enfin, une chambre peut ou non être habitée par un monstre. Celui-ci dispose des points de
force égale à 40. Lorsque l’héros rentre dans une pièce, il doit systématiquement combattre le
monstre s’il existe. Après le combat, le monstre est détruit. Aussi, puisque le combat nécessite de
l’énergie, les points de force du monstre sont soustraits aux points de vie de l’héros. Lorsque l’héros
perd tous ses points de vie, lorsqu’il atteint la sortie ou lorsqu’il se trouve dans une trappe, le jeu se
termine.
L’objectif de ce problème est de proposer une implémentation objet de ce jeu. A cet effet,
nous supposons qu’on va utiliser les cinq classes suivantes : Chambre, Porte, Héros, Monstre,
Labyrinthe. En ce qui concerne la classe labyrinthe, on dispose de la déclaration suivante qu’on
compte utiliser sans aucune modification :
Class Labyrinthe
{
Public
Labyrinthe (char * nom, int pv) ;
// le nom et les points de vie de l’héros
Void construire () ; // construit le labyrinthe (chambre, couloir, héros, monstres)
Bool coince_dans_une_trape () const
// informe si l’héros est coincé ou pas dans une trappe
Bool déplacer (Direction d) ;
// déplace l’héros dans la direction d et
// retourne un booléen informant si le déplacement a pu se faire ou non
Char * emplacement () const ;
// informe l’emplacement de la sortie par rapport à la position de l’héros,
// le résultat pouvant être : Nord, Sud, Est, Ouest, Nord-Est, Nord-Ouest, Sud-Est, Sud-Ouest
Bool fin () const ; //informe si le jeu est terminé ou pas
Bool gagant () const ; //informe si l’héros a gagné ou a perdu
~ Labyrinthe () ;
Private
Chambre * chambre_entrée ;
Chambre * chambre_sortie ;
Héros le_héros ;
} ;
Sachant que : Direction = enum {nord=0, sud=1, est=2, ouest=3} ;
Questions :
1. Compréhension du jeu. Dessiner trois chemins pouvant être empruntés par un héros
disposant initialement de 100 points de vie, dans le labyrinthe de la fig. 1, reliant sa position
initiale à sa position dans la fin du jeu qui respectivement laisse dans les situations suivantes :
(a) l’héros a gagné, ( l’héros a perdu tous ses points, © l’héros est bloqué dans une trappe.
2. Modélisation. Donner le diagramme de classes selon le formalisme UML vu en cours.
Argumenter brièvement chaque relation (agrégation, composition et ou association) en
s’appuyant sur le texte de l’énoncé. N’oublier pas de commenter les opérations des classes.
3. Ecrire la déclaration et l’implémentation en C++ de chacune des classes : Monstre, Héros,
Chambre et Porte. Dans le but de réduire le code, on suppose pour cette question que la
classe héros hérite de la classe Monstre (bien que bizarre !).
Remarque : il est fortement conseillé de ne pas séparer la déclaration d’une classe de son
implémentation.
4. Implémentation de la classe Labyrinthe.
4.1 Ecrire le code C++ de la méthode ‘’construire’’, sachant qu’on veut construire le mini
labyrinthe de la figure suivante :
4.2 Dans le cas général, écrire le code C++ des méthodes ‘’ déplacer ‘’, ‘’gagnant‘’ , ‘’fin’’.
4.3 On suppose qu’une trappe contient au maximum deux chambres, écrire le code C++ de la
méthode ‘’coince_dans_une_trappe’’.
4.4 On suppose que le labyrinthe est de forme rectangulaire et ne comportant pas de zone
vide, commenter l’algorithme de la méthode ‘’emplacement’’.
4.5 Doit-on écrire du code dans le constructeur respectivement dans le destructeur.
Argumenter votre réponse. Dans l’affirmative, donner le code C++ correspondant à la
construction du mini labyrinthe de la question 4.1.
5. Le main (). Ecrire un programme principal qui permet de dialoguer avec un joueur en vue de
résoudre le jeu. Le programme doit permettre au joueur d’introduire son nom ainsi que ses
points de vie de déplacer l’héros dans l’une des directions suivantes (Nord, Sud, Est, Ouest),
doit donner l’emplacement de la chambre de sortie, doit indiquer les déplacements non
permis, doit féliciter (resp. consoler) par un message le joueur dans le cas où il réussit (resp il
ne réussit pas) à déplacer l’héros jusqu’à la chambre de sortie.
Remarque : vous pouvez assurer une partie de l’affichage dans la méthode déplacer()
mon code dans ce moment là est le suivant
Port.h
#ifndef PORTE_H
#define PORTE_H
class Porte
{
public:
bool get_etat();
void set_etat(bool V);
Porte();
~Porte();
private:
bool etat;
};
#endif // PORTE_H
Porte.cpp
include "..\include\Porte.h"
Porte::Porte()
{
//ctor
}
Porte::~Porte()
{
//dtor
}
bool Porte::get_etat()
{
return (etat);
}
void Porte::set_etat(bool V)
{
etat=V;
}
Monstre.cpp
#include "..\include\Monstre.h"
Monstre::Monstre()
{
//ctor
}
Monstre::~Monstre()
{
//dtor
}
void Monstre::set_ligne(int x)
{
ligne = x;
}
void Monstre ::set_colonne(int y)
{
colonne= y;
}
int Monstre::get_pt_de_vie()const
{
return (ptdevie);
}
void Monstre::set_pt_de_vie(int pt_v)
{
ptdevie= pt_v;
}
Monstre.h
#ifndef MONSTRE_H
#define MONSTRE_H
class Monstre
{
public:
void set_ligne(int x);
void set_colonne(int y);
int get_pt_de_vie()const;
void set_pt_de_vie(int pt_v);
Monstre();
~Monstre();
private:
int ptdevie;
int ligne;
int colonne;
};
#endif // MONSTRE_H
Labyrinthe.cpp
#include "..\include\Labyrinthe.h"
#include <conio.h>
#include <iostream>
#include "..\include\Monstre.h"
using namespace std;
Labyrinthe::Labyrinthe(char*nom,int pv)
{
//ctor
chambre_entree=
}
Labyrinthe::~Labyrinthe()
{
//dtor
}
void Labyrinthe::construire(Chambre t[7][7],Monstre M[3])
{
int l;
int c;
for (int i=0;i<3;i++)
{
cout<<"saisir le Monstre numero"<<i;
cout <<"l'abscisse du Monstre";
cin>>l;
M[i].set_ligne(l);
cout<<"l'ordonnee du Monstre";
cin>>c;
M[i].set_colonne©;
}
for(int i=0;i<7;i++)
{
for (int j=0; j<7;j++)
{
for(int k=0;k<4;k++)
{
t[i][j].set_porte(k,true);
}
}
}
for (int j=0;j<7;j++)
{
t[0][j].set_porte(1,false);
t[6][j].set_porte(3,false);
}
for (int i=0;i<7;i++)
{
t[i][0].set_porte(4,false);
t[i][6].set_porte(2,false);
}
}
Labyrinthe.h
#include "Porte.h"
class Labyrinthe
{
public:
Labyrinthe(char*nom,int pv);
void construire(Chambre tab[7][7],Monstre M[3]);
bool coince_dans_une_trappe ()const;
bool deplacer(Direction d);
char*emplacement() const;
bool fin() const;
bool gagnant() const;
~Labyrinthe ();
private:
Chambre*chambre_entree;
Chambre*chambre_sortie;
Heros le_heros;
};
#endif // LABYRINTHE_H
Heros.h
#ifndef HEROS_H
#define HEROS_H
#include "Monstre.h"
class Heros : public Monstre
{
public:
bool combattre();
void set_heros();
Heros ();
~Heros();
private:
char nom[20];
};
#endif // HEROS_H
Heros.cpp
#include "..\include\Heros.h"
Heros::Heros()
{
//ctor
}
Heros::~Heros()
{
//dtor
}Chambre.cpp
#include "..\include\Chambre.h"
#include <iostream>
using namespace std;
void Chambre::set_trappe(bool valeur)
{
trappe=valeur;
}
bool Chambre::get_trappe()
{
return(trappe);
}
void Chambre::set_porte(int n,bool val)
{
Tab[n].set_etat(val);
}
bool Chambre::get_porte(int i)
{
return (Tab[i].get_etat());
}
Chambre.h
#ifndef CHAMBRE_H
#define CHAMBRE_H
#include"Porte.h"
class Chambre
{
public:
Chambre ();
~Chambre();
void set_porte(int n,bool val);
bool get_porte(int i);
void set_trappe(bool valeur);
bool get_trappe();
private:
Porte Tab[4];
bool trappe;
};
#endif // CHAMBRE_H
NB: deadline cette semaine (aidez moi SVP)