EXPOSE DU GROUPE N°4

THEME :

CONCEPTION DU JEU
PENDU

Classe:: LICENCE INFORMATIQUE 1

Logiciel:: VISUAL STUDIO 2012
Langage: C++

Présentée par:

Promotion 2020-2021
2020
PREAMBULE
Ce document constitué de 38 pages est un travail fournit par un
groupe d’étudiants de la première année licence informatique du
CFI-CIRAS promotion 2020-2021 2021 dans le but de répondre a un
travail pratique sur la conception d’un jeu de pendu remit le 01
Juillet 2020 par Mr OYERE ,responsable du cour de
programmation orienté objet.
objet Il est divise en deux parties; la
première présente la modélisation avec quelque diagrammes
UML(cas d’utilisation, classe),les difficultés rencontrées ainsi la
description de l’implémentation des différentes fonctionnalitees.La
seconde partie est consacrée a l’implémentation du code source en
c++
PRESENTATION DU JEU
La version officielle du < Jeu du Pendu > se joue a plusieurs
personnes. Nous supposerons ici que le jeu se joue a deux.
L'un des joueurs commence par proposer un mot a deviner.
Supposez que l'autre joueurs ne voit pas ce mot. Il n'en connait
au départ que la longueur. Ce deuxième joueur propose ensuite
une lettre. Si cette lettre est présente dans le mot, toutes ses
occurrences sont indiquées.
indiquées Sinon, ce joueur < progresse > sur
le chemin de la pendaison. Au bout d'un certain nombre NMAX
étapes, il a perdu : il est < pendu >.
La partie se termine lorsque chacun des deux joueurs a
propose a l'autre un mot a deviner. Chaque joueur qui parvient
a en pendre un autre gagne un point. Chaque joueur qui trouve
un mot (c.-a-d. propose la dernière lettre a trouver) gagne un
point. A la n de la partie, gagne celui qui est encore en vie et a
le plus de points. Au terme de la pendaison (NMAX-eme
étape), le pendu pourrait ressembler a un petit pendu (ici 3
essais) :
Le jeu du pendu pouvant se jouer a plusieurs joueurs (un qui
propose le mot et les autres essayant a tour de rôle de le
deviner), la solution proposée ne fait pas d'hypothèse
sur le nombre de joueurs.

1
 DIAGRAMME DE CAS D’UTILISATION
JeuPendu

Consulter
l’aide Saisir
joueur

<étendre>

<inclus>

Description
du jeu Proposer
mot

<étendre>
<inclus> Machine
Vérifier
Consulter
<inclus> tentative
menu <inclus> Proposer
lettre

<étendre> <inclus>
Rechercher
lettre

Sélectionner
Joueur <étendre>
Mode
Afficher
résultat

Mutijoueurs Arcade

2
DIAGRAMME DE CLASSE

+Joueur
#m_nom
#m_npoint
#m_etape
+getNom
+getPoints 1..* +Pendu
+getEtape
+incrPoint -m_joueurs
+incrEtape -m_tentative
+reset -m_adeviner
+affiche
+proposerMot +estPendu
+proposerLettre +afficher
1 +jouer
#estDansMot
#inclureDansMot
#initAdeviner
#initTentative
#devinerMot

+Humain +Machine
-m_dict
m_dict

+proposerMot +proposerMot
+proposerLettre +proposerLettre

3
DESCRIPTION DE L’IMPLEMENTATION
Le programme a été développé en C++ sur Visual studio 2012.Le
code source se divise essentiellement en deux types de fichiers:

1)Les fichiers d’en tête(.h):

tête(
Ils contiennent:
•La déclaration d’une seule classe avec ses attributs et les
prototypes de ses méthodes.
•Les prototypes des fonctions optionnelles de l’applications ainsi que
les prototypes des fonctions de validation de saisi

2)Les fichiers sources(.cpp)

sources
Ils contiennent:
Chacune, l’implémentation des méthodes d’une classe
Chacune, l’implémentation d’une fonctions optionnelle ou de
validation
Les commentaires ont été places pratiquement avant
l’implémentation d’une méthode et les mots clés du langage C++ en
mis en bleu pour faciliter la compréhension et la lisibilité du code

*MotsDico.txt
C’est un dictionnaire de mots saisi au clavier, permettant au joueur
machine de sélectionner un mot a deviner lors d’une partie en mode
arcadre

DIFFCULTEES RENCONTREES
La mise en place d’un diagramme de séquence
La génération automatique des mots a deviner par la machine
La capacité d’effectuer un retour au menu principal a certains
niveau de l’application
Une partie de jeu avec plusieurs joueurs machines
Mis a jour du nombre de tentatives des joueurs

4
5
Algorithmique, Programmation
1)Classe
Classe Joueur
Joueur.h:
#ifndef JPJOUEUR_CLASS
#define JPJOUEUR_CLASS
#include <iostream>
#include <string>
using namespace std;
class Joueur
{
protected:
string m_nom; // nom du joueur
int m_npoints; // # de points cumules
int m_etape; // etape

public:
Joueur(const string& n);
virtual ~Joueur();
const string& getNom() const;;
int getPoints() const;
int getEtape() const;
void incrPoints();
void incrEtape();
void reset();
void affiche();

/** Permet au joueur de proposer un mot*/

virtual string proposerMot() const = 0;

/** Permet au joueur de proposer une lettre*/

virtual char proposerLettre() const = 0;
};
#endif

6
Joueur.cpp:
#include "Joueur.h"

/**Constructeur normal*/
Joueur :: Joueur(const string&
& n): m_nom(n), m_npoints(0),
m_etape(0){
}

/**Destructeur virtuel*/
Joueur :: ~Joueur()
{}
/**Accesseur le nom du joueur*/
const string&& Joueur :: getNom() const
{
return m_nom;
}
/**Accesseur du nombre de points du joueur*/
int Joueur :: getPoints() const
{
return m_npoints;
}

/**Accesseur de l’etape atteinte par le joueur*/

int Joueur :: getEtape() const
{
return m_etape;
}
/**Modifieur du nombre de points du joueur*/
void Joueur :: incrPoints()
{
++m_npoints;
}
/**Modifieur du numero etape*/
void Joueur :: incrEtape()
{
++m_etape;
}
7
/**Reinitialise le # d’etapes a zero avant
de recommencer une partie*/
void Joueur :: reset()
{
m_etape = 0;
}

/** affiche les joueurs */

void Joueur :: affiche(){
cout<<"nom
<<"nom du joueur: "<<m_nom<<endl;
"<<m_nom<<
cout<<"nombre
<<"nombre de point du joueur: "<<m_npoints<<endl;
"<<m_npoints<<
cout<<"etape
<<"etape du joueur: "<<m_etape<<endl;
"<<m_etape<<
}

1)Classe Pendu
Pendu.h
#ifndef JPPENDU_CLASS
#define JPPENDU_CLASS
#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
using namespace std;
#include "Joueur.h"

/**
Represente des parties du jeu du pendu
*/

class JeuPendu
{
private:
<Joueur*> &m_joueurs;
const vector<Joueur*>
string m_adeviner; // mot cache
string m_tentative; // mot tente

8
public:
JeuPendu(const vector<Joueur*>&
<Joueur*>& j);
bool estPendu(int nb);
void afficher(int n);
void afficher();
void jouer();
protected:
bool estDansMot(char c) const;
const
void inclureDansMot(char c);
void initADeviner(unsigned k);
void initTentative();
bool devinerMot(unsigned k);
};
#endif

Pendu.cpp:
#include "Pendu.h"

/**Constructeur normal*/
JeuPendu :: JeuPendu(const
const vector<Joueur*>&
vector j): m_joueurs(j)
{}
bool JeuPendu :: estPendu(int nb){
if(nb==3)
{
return true;
}
else
{
return false;
}
}

void JeuPendu :: afficher(int n){

cout<<n;
}

9
/**Affiche les resultats d’une partie*/
void JeuPendu :: afficher()
{
cout<<endl<<"La
<<"La partie est finie. Les resultats:"<<endl;
for (unsigned j = 0; j < m_joueurs.size(); ++j)
{
Joueur &joueur = *m_joueurs[j];
cout<<"Joueur "
<<joueur.getNom()
<<" ("<<(j+1)<<") ==> "
<<(!estPendu(joueur.getEtape())
? "EN VIE"
: "PENDU...")
<<" (points: "
<<joueur.getPoints()
<<")"<<endl;
}
cout<<endl;
}

/**
Boucle principale d’une partie
*/
void JeuPendu :: jouer()
{
// Reinitialise les status des joueurs
for (unsigned k = 0; k < m_joueurs.size(); ++k)
{
m_joueurs[k]->reset();
>reset();
}

10
// Fait jouer chacun des joueurs à tour de rôle
for (unsigned k = 0; k < m_joueurs.size(); ++k)
{
// Initialise le mot à deviner par le joueur k
initADeviner(k);
// Initialise la tentative
initTentative();
// Les joueurs autres que k sont sollicites pour
// proposer des lettres
bool b = devinerMot(k);
if (b==false)
{
cout<<"ADeviner
<<"ADeviner etait: "<<m_adeviner<<endl;
"<<m_adeviner<<
}
}
}

/**Teste si un caractère est present dans le mot à deviner,

et s’il n’a pas dejà été propose*/
bool JeuPendu :: estDansMot(char c) const
{
return (m_adeviner.find(c) != string::npos)
&& (m_tentative.find(c) == string::npos);
}

/**Inclut la lettre dans la tentative*/

void JeuPendu :: inclureDansMot(char
inclureDansMot( c)
{
for (unsigned j = 0; j < m_tentative.size(); ++j)
{
if (c == m_adeviner[j])
{
m_tentative[j] = c;
}
}
}
11
/**Permet au joueur d’initialiser le mot à deviner*/
void JeuPendu :: initADeviner(unsigned
(unsigned k)
{
cout<<endl<<"Au joueur "
<<m_joueurs[k]->getNom()
>getNom()
<<" ("
<<(k+1)
<<") de proposer un mot:"<<endl;
mot:"<<
m_adeviner = m_joueurs[k]-->proposerMot();
}

/**Initialise l’attribut <tentative> avec des ’_’*/

void JeuPendu :: initTentative()
{
m_tentative="";
int i=0;
int cpt=m_adeviner.size();
for(i=0;i<cpt;i++){
m_tentative=m_tentative+"_";
}
//m_tentative = string(m_adeviner.size(),
(m_adeviner.size(), ’_’);
}
bool JeuPendu :: devinerMot(unsigned
unsigned k)
{
// Tant qu’un joueur a réussi a jouer et que le mot n’est
// pas devine: on continue de jouer
for(;;)
{
bool ajouer = false;
for (unsigned j = 0; j < m_joueurs.size(); ++j)
{
// Le joueur k a propose le mot: on le saute
if (j == k)
{
continue;
}
12
 Joueur &joueur = *m_joueurs[j];
// Si le joueur j ne peut pas jouer: passe au suivant
if (estPendu(joueur.getEtape()))
{
continue;
}
// Ici au moins un joueur a réussi a jouer
ajouer = true;
// Affiche la tentative actuelle, le status du joueur j,
// et demande sa lettre proposée
cout<<endl<<"TENTATIVE:
<<"TENTATIVE: "<<m_tentative<<endl;
"<<m_tentative<<
cout<<"
<<" Joueur "<<joueur.getNom()<<" ("<<(j+1)<<") lettre?
";
char lettre = joueur.proposerLettre();
// Actualise le score du joueur
if (estDansMot(lettre))
{
inclureDansMot(lettre);
cout<<"Bravo:
<<"Bravo: "<<m_tentative<<endl;
"<<m_tentative<<
if (m_tentative == m_adeviner)
{
joueur.incrPoints();
cout<<"==>
<<"==> GAGNE !"<<endl;
!"<<
return true;
}
}
else
{
joueur.incrEtape();
cout<<"Pas
<<"Pas de chance:"<<endl;
chance:"<<
afficher(joueur.getEtape());
if (estPendu(joueur.getEtape()))
{
cout<<"==>
<<"==> PERDU !"<<endl;
!"<<
m_joueurs[k]->incrPoints();
>incrPoints();
return false;
}
13
}
}
// Si aucun des joueurs ne peut plus jouer: le joueur k
// a gagne tous les points: on sort
if (ajouer==false)
{
return false;
}
}
}

3)Classe Humain:
Humain.h:
#ifndef JPHUMAIN_CLASS
#define JPHUMAIN_CLASS
#include <iostream>
#include <string>
using namespace std;
#include "Joueur.h

/**
Represente des joueurs "Humain"
*/

class Humain : public Joueur

{
typedef Joueur super;

public:
Humain(const string& n);
string proposerMot() const;
char proposerLettre() const;
};
#endif

14
Humain.cpp
#include "Humain.h"
#include "ValidationEntier.h"
#include "ValidationMot.h"
#include "ValidationLettre.h"

//#include "Joueur.h"
/**
Constructeur normal
*/
Humain :: Humain(const string&
& n): super(n)
{}

/**
Propose un mot a faire deviner
*/
string Humain :: proposerMot() const
{
bool validMot=false;
string s;

do
{
cout<<"(Les
<<"(Les autres joueurs ne regardent pas)"<<endl;
pas)"<<
cout<<"Mot propose? ";
cin>>s;
validMot=isName(s);
}while (!validMot);
return s;
}

15
/**
Propose une lettre
*/
char Humain :: proposerLettre() const
{
int nombre=0;
bool validLettre=false;
string name;
char c=' ';
do
{

cin>>name;
validLettre=isCaractere(name);
nombre=name.length();
if(nombre>=2)
{
cout<<"DONNEES
<<"DONNEES SAISIES INCORRECTES,VEUILLER SAISIR
UNE SEULE LETTRE "<<endl;
validLettre=false;
}

}while (!validLettre);
c=name[0];

return c;
}

16
4)Classe Machine:
Machine.h:
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <vector>
using namespace std;
#include "Joueur.h"

//Represente des joueurs "Ordinateur«

class Machine : public Joueur

{
typedef Joueur super;
public:
Machine(const string& n, const vector<string>& d);
virtual string proposerMot() const;
virtual char proposerLettre() const;
private:
const vector<string> &m_dict; // dictionnaire
};
#endif

17
#include "Machine.h"

/*Constructeur normal Initialise le générateur de nombres

aléatoires*/
Machine::Machine(const string&& n, const vector<string>& d):
super(n), m_dict(d)
{
srand(time(0));
}

/*
Propose un mot a faire deviner: Tire un nombre de la
taille du dictionnaire et retourne le mot correspondant
*/
string Machine::proposerMot() const
{
string s = m_dict[ rand() % m_dict.size() ];
cout<<"Mot propose "<<s<<endl endl;
return s;
}

/*
Propose une lettre.
Génère aléatoirement une lettre de l’alphabet.
*/

char Machine::proposerLettre() const

{
// On pourrait pu mémoriser un tableau de booléens
// des lettres dejà proposées afin d’éviter de proposer
// plusieurs fois la même lettre... on admettra que le
// générateur est un "bon" générateur uniforme
char c = char(int('a') + rand() % 26);
cout<<c<<endl;
return c;
}

18
LES FONCTONS:
1)Multijoueur
Permet à au moins deux juoueurs, tous humain de s’affronter

Multijoueur.h
#include <iostream>
using namespace std;
#include <vector>
#include <string>
#include "Joueur.h"
#include "Humain.h"
#include "Pendu.h"

void Multijoueur();

Multijoueur.cpp
#include "Multijoueur.h"
#include "ValidationEntier.h"
#include "ValidationMot.h"
#include "ValidationLettre.h"

void Multijoueur(){
vector<Joueur*>*> listejoueur;
int i=0,n=0,j=0,p=0,conf=0,nombre=0,x=0,vt=0;
string nom,num,name;
bool valid=false;
bool validMot=false;
bool validLettre=false;
char c;

cout<<"---------------------------------------------------------
---------------------------------------------------------<<endl;
cout<<"
<<" <<<<<< MODE MUTIJOUEUR>>>>> "<<endl; "<<

19
while(conf==0)
{
cout<<"---------------------------------------------------------
---------------------------------------------------------<<endl;
do
{
cout<<"entrer
<<"entrer le nombre du joueur"<<endl;
joueur"<<
cin>>num;
valid=isNumber(num);
if(valid)
{
if(stoi(num)==1)
{
cout « "Le nombre de joueurs doit être supérieur a 1" «endl;
valid=false
}
}
}while(!valid);
n=stoi(num);

for(i=0;i<n;i++)
{
do
{
cout<<"Veuillez
<<"Veuillez entrer un nom sans chiffre pour le joueur
"<<j+1<<endl;
cin>>nom;
validMot=isName(nom);
}while (!validMot);
listejoueur.push_back(new Humain(nom));
j++;
}
i=0;
JeuPendu* joueurselect=new JeuPendu (listejoueur);
joueurselect->jouer();
joueurselect->afficher();
cout<<endl;

20
/* Effectue les parties*/
cout<<"Une
<<"Une autre partie (o/n)? ";
do
{
cin>>name;
validLettre=isCaractere(name);
nombre=name.length();
if(nombre>=2)
{
validLettre=false;
}
if(validLettre=1)
{
if((name[0]!='o') && (name[0]!='n'))
{
cout<<"VEUILLER
<<"VEUILLER SAISIR 'o'(oui)/'n'(non) "<<endl;
"<<
validLettre=false;
}
}
}while (!validLettre);
c=name[0];
if (c== 'o')
{
conf=0;
cout<<"****
<<"**** NOUVELLE PARTIE DE JEU ****"<<endl;
****"<<
for(i=0;i<=listejoueur.size();i++){
<=listejoueur.size();i++){
listejoueur.pop_back();
}
i=0;
j=0;
}
if(c=='n')
{
conf++;
cout<<"MERCI
<<"MERCI D'AVOIR JOUER"<<endl;
JOUER"<<
}
}
21
2)Arcadre:
Permet à au moins un joueur humain de joueur contre la machine
Arcadre.h:
#include <iostream>
using namespace std;
//#include "Multijoueur.h"
#include <vector>
#include <string>
#include "Joueur.h"
#include"Humain.h"
#include "Pendu.h"
#include "Machine.h"
//#include "JeucontreMachine.h"
#include "LectureDico.h"
void Arcadre();

Arcadre.cpp
#include "Arcadre.h"

void Arcadre(){
vector<string> listmot;
string nom;
vector<Joueur*> *> listejoueur;
string nomValid,num,name;
bool valid=false;
bool validMot=false;
bool validLettre=false;
char c;
cout<<"---------------------------
---------------------------"<<endl;
cout<<"
<<" MODE ARCADE "<<
"<<endl;
listmot=Lecturedico();
Joueur* PC=new Machine("PC",listmot);
while(conf==0)
{
cout<<"---------------------------
---------------------------"<<endl;

22
do
{
cout<<"entrer
<<"entrer le nombre de joueurs humain"<<endl;
humain"<<
cin>>num;
valid=isNumber(num);
}while(!valid);
for(i=0;i<n;i++)
{
do
{
cout<<"Veuiller
<<"Veuiller entrer un nom sans chiffre pour le joueur "<<j2+1<<endl;
"<<j2+1<<
cin>>nomValid;
validMot=isName(nomValid);
}while (!validMot);
listejoueur.push_back(new Humain(nom));
j2++;
}
i=0;
listejoueur.push_back(PC);
JeuPendu* joueurselect=new JeuPendu (listejoueur);

joueurselect->jouer();
joueurselect->afficher();
cout<<endl;

/* Effectue les parties*/

cout<<"Une autre partie (o/n)? ";
do
{
cin>>name;
validLettre=isCaractere(name);
nombre=name.length();
if(nombre>=2) validLettre=false;
if(validLettre=1)
{
if((name[0]!='o') && (name[0]!='n'))
{
cout<<"VEUILLER
<<"VEUILLER SAISIR 'o'(oui)/'n'(non) "<<endl;
"<<
validLettre=false;
}
}
}while (!validLettre);
23
c=name[0];
if (c== 'o')
{
conf=0;
cout<<"******
<<"****** NOUVELLE PARTIE DE JEU *******"<<endl;
*******"<<
for(i=0;i<=listejoueur.size();i++){
(i=0;i<=listejoueur.size();i++){
listejoueur.pop_back();
}
i=0;
j2=0;
}
if(c=='n')
{
conf++;
cout<<"MERCI
<<"MERCI D'AVOIR JOUER"<<endl;
JOUER"<<
}
}
}

4)Description: Présentation du jeu

Description.h:
#include <iostream>
using namespace std;
void Description();

Description.cpp
#include "Description.h"
#include <iostream>
#include "Aide.h"
#include "ValidationEntier.h"
#include "ValidationMot.h"
#include "ValidationLettre.h"
#include "Multijoueur.h"
using namespace std;

void Description(){
cout<<"-------------------------------------------------------------
-------------------------------------------------------------<<endl;
cout<<"
<<" <<<<<<< DESCRIPTION DU JEU >>>>>>>>>> "<<endl; "<<
cout<<"------------------------------------------------------------------
------------------------------------------------------------------"<<endl;
cout<<"La
<<"La version officielle du <<jeu de pendu>> se joue a plusieurs
personnes. L'un des joueurs "<<endl endl;
24
cout<<"commencent par proposer un mot a deviner. Supposons que l'autre
joueur ne voit pas ce mot."<<endl;
cout<<"Il n'en connait au départ que sa longueur. Le joueur suivant propose
ensuite une lettre. Si "<<endl;
cout<<"cette lettre est présente dans le mot, toutes ses occurrences sont
indiquées. Sinon, ce <<joueur>> "<<endl;
cout<<"progresse sur la voie de la pendaison. Au bout d'un certain nombres
NMAX etapes, il a perdu"<<endl;
cout<<":il est <<pendu>> "<<endl;
cout<<"Au terme de la pendaison(NMAX-eme
pendaison(NMAX etape), le pendu pourrait
ressembler a un petit pendu"<<endl<<endl;
cout<<" __________"<<endl;
cout<<" |/ | "<<endl;
cout<<" | o "<<endl;
cout<<" | -|- "<<endl;
cout<<" | | "<<endl;
cout<<" | / "<<endl;
cout<<" | "<<endl;
cout<<" | "<<endl;
cout<<"_/|\________
________ #e=5"<<endl<<endl;
int val=0,i=0;
string num;
bool valid=false;
do
{
cout<<"ENTRER VOTRE CHOIX PARMI LE MENU CI-DESSUS CI "<<endl;
cin>>num;
valid=isNumber(num);
if(valid==1)
{
if(stoi(num)==3)
{
cout<<"VOUS VOUS TROUVEZ DEJA SUR 'DESCRIPTION DU JEU'
"<<endl;
valid=0;
}
}
}while (!valid);
25
val=stoi(num);
while (i==0){
if((val>=1) && (val<=5))
{
i=1;
switch(val)
{
case 1: Multijoueur();
break;
case 2:cout<<"bonjour"<<endl;
break;
case 4: Aide();
break;
}
}
}
}

4)Aide:
Aide.h:
#include <iostream>
using namespace std;

void Aide();

Aide.cpp:
#include "Aide.h"
#include "Description.h"
#include "ValidationEntier.h"
#include "ValidationMot.h"
#include "ValidationLettre.h"
#include "ValidationEntier.h"
#include "ValidationMot.h"
#include "ValidationLettre.h"
#include "Multijoueur.h"
26
void Aide(){
cout<<"----------------------------------------------
----------------------------------------------"<<endl;
cout<<"
<<" <<<<<<<<< AIDE >>>>>>>>>>> "<<endl; "<<
cout<<"------------------------------------------------------------
------------------------------------------------------------"<<endl;
cout<<"MODE
<<"MODE MUTIJOUEUR"<<endl;
MUTIJOUEUR"<<
cout<<"LE
<<"LE MODE MUTIJOUEUR PERMET A AU MOINS
DEUX JOUEURS TOUS HUMAINS";
cout<<"
<<" DE S'AFFRONTER ENTRE EUX"<<endl; EUX"<<
cout<<"MODE ARCADE"<<endl endl;
cout<<"LE
<<"LE MODE ARCADE PERMET A AU MOINS UN
JOUEURS HUMAIN";
cout<<"
<<" D'AFFRONTER LA
MACHINE(ORDINATEUR)"<<
MACHINE(ORDINATEUR)"<<endl<<endl;

int val=0,i=0;
string num;
bool valid=false;

do
{
cout<<"ENTRER VOTRE CHOIX PARMI LE MENU CI- CI
DESSUS"<<endl;
cin>>num;
valid=isNumber(num);
if(valid==1)
{
if(stoi(num)==4)
{
cout<<"VOUS
<<"VOUS VOUS TROUVEZ DEJA SUR 'AIDE' "<<endl;
"<<
valid=0;
}
}
}while (!valid);
val=stoi(num);

27
while (i==0)
{
if((val>=1) && (val<=5))
{
i=1;
switch(val)
{
case 1: Multijoueur();
break;
case 2:Arcadre()*;
break;
case 3: Description();
}
}
}
}

5)LectureDico:
Permet au joueur machine de sélectionner un mot a partir du fichier
MotsDico.txt (dictionnaire de mots)
LectureDico.h
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
using namespace std;
vector<string> Lecturedico();

LectureDico.cpp;
#include "LectureDico.h"

vector<string> Lecturedico()
{
vector<char> mot2;
vector<string> tab;
28
vector<string> mots;
ifstream fichier;
fichier.open("MotsDico.txt");
if (fichier.fail())
{
cerr<<« Erreur, fichier non ouvert"<<endl;
}
char element;
string mo="",p="";
int n=0,i=0;
while(!fichier.eof())
{
fichier>>element;
mot2.push_back(element);
}
for(i=0;i<mot2.size();i++)
{
mo=mo+mot2[i];
}
i=0;
for(i=0;i<mo.size();i++)
{
if(mo[i]!=';')
{
p=p+mo[i];
}
else
{
tab.push_back(p);
p="";
}
}
cout<<"les mots sont: "<<endl;
for(i=0;i<tab.size();i++)
{
cout<<tab[i]<<endl;
}
return tab;
}

29
6)Les validations:
6-1) IsNumber: Pour la saisie des entiers
ValidationEntier.h
ValidationEntier.h:
#include <iostream>
#include <string>
using namespace std;
bool isNumber(string num);

ValidationEntier.cpp:
#include "ValidationEntier.h"

bool isNumber(string num)

{
int i=0;
for(i=0;i<num.length();i++){
if(!isdigit(num[i]))
{
cout<<"CARACTERE
<<"CARACTERE TROUVE: "<<num[i]<<" N'EST PAS UN
NOMBRE"<<endl;
return false;
}
}
return true;
}

6-2)IsCaractere: Pour la saisie des lettres

ValidationLettre.h:
#include <iostream>
#include <string>

using namespace std;

bool isCaractere(string num);

30
ValidationLettre.cpp:
#include "ValidationLettre.h"

bool isCaractere(string num)

{
int i=0;
for(i=0;i<num.length();i++){
if(!isalpha(num[i]))
{
cout<<"DONNEES SAISIES INCORRECTES,VEUILLER SAISIR UNE
LETTRE"<<endl;
return false;
}
}
return true;
}

6-3)IsName: Pour la saisie des mots

ValidationMot.h:
#include <iostream>
#include <string>
using namespace std;
bool isName(string num);

ValidatonMot.cpp:
#include "ValidationMot.h«

bool isName(string num)

{
int i=0;
for(i=0;i<num.length();i++){
if(!isalpha(num[i]))
{
cout<<"DONNEES SAISIES INCORRECTES"<<endl;
return false;
}
}
return true;
}
31
INTERFACE
Main.cpp:
#include <iostream>
using namespace std;
#include "Multijoueur.h"
#include <vector>
#include <string>
#include "Joueur.h"
#include "Humain.h"
#include "Pendu.h"
#include "Description.h"
#include "Aide.h"
#include "ValidationEntier.h"
#include "ValidationMot.h"
#include "ValidationLettre.h"
#include "Arcadre.h "

int main()
{
int val;
int i=0;
string num;
int reelNum;
bool valid=false;
cout<<"
<<" MENU PRINCIPALE DU JEU "<<
"<<endl;
cout<<"<<" ** 1: MULTIJOUEURS ** "<<
"<<endl;
cout <<" ** 2: ARCADE ** "<<
"<<endl;
cout<<"<<" ** 3: DESCRIPTION DU JEU ** "<<
"<<endl;
cout<<"<<" ** 4: AIDE ** "<<endl<<endl;
"<<
cout<<"*************************************************"
<<"*************************************************" <<endl;
<<
do
{
cout<<"ENTRER
<<"ENTRER VOTRE CHOIX"<<endl;
CHOIX"<<
cin>>num;
valid=isNumber(num);

32
if(valid==1)
{
if((stoi(num)<1) || (stoi(num)>4))
i(num)>4))
{
cout<<"VEUILLER
<<"VEUILLER ENTRER UNE VALEUR COMPRISE ENTRE 1 ET
4 SELON VOTRE CHOIX DANS LEMENU CI-DESSUS
CI "<<endl;
valid=0;
}
}

}while (!valid);
val=stoi(num);
switch(val){
case 1: Multijoueur();
break;
case 2: Arcadre();
break;
case 3: Description();
break;
case 4: Aide();
break;
}

return 0;

33
CONCLUSION
Tout au long de ce projet, nous avons été amenés à concevoir et
implémenter une application dans le cadre d’un projet pédagogique sous
Visual studio 2012 en C++ .Conformément
Conformément a ce que nous avons spécifié,
nous sommes parvenu à mettre en œuvre une application console sous le
nom de « JEU PENDU ».
Ce projet a été très bénéfique. Ce travail était l’occasion
d‘appliquer les connaissances acquises durant notre formation au CFI-CIRAS.
En effet, il mêlait ensemble plusieurs disciplines et nous a permis de mettre à
profit les études du semestre précédent et de parfaire nos connaissances
dans des matières déjà étudiées au premier semestre. Les acquis du cours de
programmation orienté objet étant sans cesse sollicités et ce nouveau
développement de projet en C++ nous a encore permis d’aller lus loin dans
les possibilités du langage et d’acquérir de nouvelles connaissances.
Enfin, les fonctionnalités offertes par cette application répond
grandement aux problèmes posés pour le bon fonctionnement de ce jeu.
Toutefois, il existe toujours des améliorations à envisager pour rendre une
application encore plus performante.
performante

34