Débutant en c++/pendu

masque_joueur=std::string(mot_cache.size(),'*');

masque_joueur[found]=lettre[0];

#include <iostream>
#include <iomanip>
#include <cstdlib> //Utilisation de srand()
#include <string>   //Utilisation des chaînes de caractères string
#include <ctime>   //Utilisation de time()
#include <vector>
#include <fstream>  //Utilisation de ifstream



#define Debutant 9
#define Intermediaire 7
#define Expert 5
#define Max_Char 50 //Nombres de caractères maximum dans une ligne du fichier texte



using namespace std;

//=======Définition des fonctions=========

void verification_mot(string &mot_cache,bool &gagne);
void verification_saisie(int &proposition_joueur, string masque_joueur,string mot_cache);
void afficher_pendu(int proposition_joueur);
int niveau(int difficulte);
bool choix_aide(bool &aide);
void selection_mot(string &mot_cache);
void mode_jeu(bool &mode_jeu, string &mot_cache);

//====Probleme à régler====
    //-->niveau empecher de rentrer un autre choix que 1,2 et 3
    //-->pour les autres empechement; empecher de rentrer une lettre
    //-->que faire en cas ou le joueur propose la derniere lettre qui revele le mot cache
    //-->mode 2 joueurs
    //-->statistique
    //-->Pb du srand
    //-->Pb des lettres deja essayee dans verification_saisie
    //-->Pb de sortie du jeu(while) dans verification saisie

void afficher_entete()
{
    int i;
    for(i=0;i<=78;i++){cout << '=';}cout<<endl;
    for(i=0;i<=78;i++){cout << '=';}cout<<endl;
    for(i=0;i<=15;i++){cout << '=';}cout<<" __"<<' '<<" _"<<' '<< " " <<"   "<<"  " <<' '<<"        "<<" _"<<" "<<"  _";for(i=0;i<=11;i++){cout << ' ';}for(i=0;i<=22;i++){cout << '=';}cout<<endl;
    for(i=0;i<=15;i++){cout << '=';}cout<<"  |"<<' '<<"|_"<<' '<<"| |"<<"   "<<"|\\"<<' '<<"| |   "  <<"|_|"<<" "<<"|_"" ""|\\ |"" ""|\\"" | |";for(i=0;i<=22;i++){cout << '=';}cout<<endl;
    for(i=0;i<=15;i++){cout << '=';}cout<<"|_|"<<' '<<"|_"<<' '<<"|_|"<<"   "<<"|/" <<' '<<"|_|   "  <<"|  "<<" "<<"|_"" ""| \\|"" ""|/ ""|_|" ;for(i=0;i<=22;i++){cout << '=';}cout<<endl;
    for(i=0;i<=78;i++){cout << '=';}cout<<endl;
    for(i=0;i<=78;i++){cout << '=';}cout<<endl;
    cout<<endl<<endl<<endl;
}

//==============================Programme prinicpal================================//
int main()
{
    int difficulte, i,proposition_joueur,indice,indice_mot;
    bool aide_repetition,aide;
    bool jeu,choix_jeu;
    string masque_joueur,mot_cache;

    int tentative;
    srand(time(NULL));

    //afficher_entete();

//Choix du mode de jeu

    //mode_jeu(jeu,mot_cache);
    //cout << "le mode jeu est : "<<boolalpha<<mode_jeu <<endl;


//Choix du niveau de difficulté

    proposition_joueur = niveau(difficulte);
    //system ("cls");

//sélection du mot
    selection_mot(mot_cache);

//Début du jeu

    verification_saisie(proposition_joueur, masque_joueur,mot_cache);

//========================Dédié au test========================//

//Test de vérification mot

    //verification_mot(string mot_cache);




    system ("pause");
    return 0;

}

void selection_mot(string &mot_cache)
{
    //Déclaration des variables locales
    string nombres_mots,str;    //Récupération du nombre de mots présents dans le fichier texte
    int intermediaire_calcul,indice_mot,ligne;
    int nb_lignes=0;
    ifstream fichier("liste_mot.txt", ios::in);  // on ouvre le fichier en lecture

        if(fichier)  // si l'ouverture a réussi
        {
                //Boucle pour compter le nombres de lignes du fichier texte

                while(fichier.ignore(Max_Char, '\n'))
                {
                    nb_lignes++;
                }
                //cout<< "le nombre de lignes est : "<<nb_lignes<<endl;

                //Replacement au début du fichier
                fichier.clear();        //La fonction membre clear remet à leur état d'origine les 4 flags de fstream.

                fichier.seekg(0, ios::beg); //Le premier argument de seekg est le premier octect où se placer
                                            //et le deuxieme argument est l'endroit du fichier à partir duquel ce situe cette ocete
                                            //soit l'octet inidqué depuis le début du fichier ios::beg


                //=====A revenir==========//
                intermediaire_calcul = rand();
                cout << "intermediaire calcul = "<< intermediaire_calcul<<endl;
                indice_mot = intermediaire_calcul*nb_lignes/ RAND_MAX;
                cout <<"indice_mot = " << indice_mot <<endl;

                //Boucle pour se placer dans une ligne du fichier texte et récupérer le mot de la ligne
                //indicé aléatoirement par indice_mot

                for(ligne=0; ligne<=indice_mot;ligne++)
                {
                    //Pour se positionner, nous ignorons tous les caracteres d'une lingne tant qu'il y en a
                    //moins que Max_Char
                    fichier.ignore(Max_Char, '\n');
                }

                //Récupération du mot_cache
                getline(fichier,mot_cache);
                cout << "Le mot cache est : "<< mot_cache <<endl;

                fichier.close();  // Fermeture du fichier
        }
        else
        {
             // sinon
                cerr << "Impossible d'ouvrir le fichier !" << endl;
        }
}

//Méthode qui vérifie si la lettre saisie par l'utilisateur se trouve dans le mot caché
void verification_saisie(int &proposition_joueur, string masque_joueur, string mot_cache)
{

//===Défintion des variables locales===

    int i;                  // Définition d'une variable locale
    char lettre;            // La saisie utilisateur est stockée dans lettre
    //string mot_cache;       // Définition locale d'un mot caché pour la vérification
    bool jeu;               // Booléen indiquant si il reste des propositions au joueur donc si il reste en jeu
    bool gagne;             // Booléen retourné de la fonction vérification_mot qui inidque la fin de la partie
    bool deja_essayee;      // Booléen retourne de la fonction saisie_deja_propossee qui indique si la lettre saisie
                            // se trouve dans le masque_joueur

//============Initialisation============

    jeu    = true;          //Le joueur est en jeu
    gagne  = false;         //Le joueur n'a pas gagné
    //proposition_joueur = 5; //Pour l'instant je force propostion_joueur=5

    size_t found;           // Utilisation de l'operaeur find_first_of
    size_t found_saisie;    // Utilisation de l'operaeur find_first_of



//Saisie d'un mot caché destiné à une vérification locale

    //cout << "Veuillez entrer un mot dedie a la verification : \t";
    //cin  >> mot_cache;


//Inistialisation de la chaine de charactere masque_joueur sous forme de 'x' et de la taille de mot_cache

    masque_joueur.insert(0, mot_cache.length(), 'x');


//===================================================================================
//=============================Début du jeu==========================================
//===================================================================================


    do
    {
        //system("cls");

        //===========test==============
        //cout << "jeu : "<< jeu<<endl;
        //=============================

        afficher_entete();
        cout << "Votre masque est : "<<'\t'<< masque_joueur<<'\n'<<endl;
        afficher_pendu(proposition_joueur);
        cout << "Votre nombre(s) de proposition est de : "<<'\t'<<proposition_joueur<<endl;

        do
        {
            cout << "Veuillez proposez une lettre : \t";
            cin  >> lettre;
            cin.ignore();
            cout << endl;
//==!!!!!!!!!!!!Ca fait pas exactement ce que je veux emepeche les repetitions a la condition ou la lettre est deja dans masque_joueur!!!!
//========================Boucle de vérification de répétition de saisie==============================

            //Définition de found qui trouve l'indice de la première occurence du caractère lettre
            //dans mot caché et la retourne dans found


            found_saisie=masque_joueur.find_first_of(lettre);


        //*******************La lettre n'a pas déjà été saisie *************************

            if (found_saisie == string::npos)
            {
                //cout <<"La lettre n a pas deja ete saisie"<<endl;
                deja_essayee=false;
            }
        //*******************************************************************************


        //*********************La lettre a déjà été saisie ******************************
            else
            {
                //cout << "La lettre a deja ete saisie"<< endl;
                deja_essayee=true;

            }
//========================Fin de la boucle de vérification de répétion de saisie=========================

        cout << "deja essayee = "<< boolalpha<< deja_essayee<<endl;

        }
        while(deja_essayee != false);

//=============Boucle de comparaison entre la lettre saisie et le mot caché==============================


    //***********La lettre ne se trouve pas dans le mot caché *****************

        //Définition de found qui trouve l'indice de la première occurence du caractère lettre
        //dans mot caché et la retourne dans found

        found=mot_cache.find_first_of(lettre);

        if (found == string::npos)
        {
            proposition_joueur = proposition_joueur - 1;
            cout << "Votre  proposition n'est pas correcte \!"<<'\n'<<endl;
            cout << "Votre nombre de propositions est de :"<<'\t'<< proposition_joueur<<endl;
        }
    //***************************************************************************




    //*******************La lettre se trouve dans le mot caché ******************


        else
        {
            while (found!=string::npos)                           //Boucle pour parcourir tout le mot
            {
                cout <<"lettre trouve : \t"<<found<<endl;        //Dédié a la verification,affiche l'indice de la lettre trouvée
                masque_joueur[found]= lettre;                    // Insère dans le masque la lettre saisie par l'utilisateur à l'indice ou elle
                                                                 //a été trouvée
                found=mot_cache.find_first_of(lettre,found+1);
            }
        }
    //*****************************************************************************




        //*************************Apppel de vérification mot**************************



        cout << "Votre masque est : "<<'\t'<< masque_joueur<<'\n'<<endl;
        verification_mot(mot_cache,gagne);
        cout <<"gagne = "<<boolalpha<<gagne<<endl;    //=========TEST+============

        //******************************************************************************

        //Mise a jour de jeu

        if (proposition_joueur == 0)
        {
            jeu = false;
        }
        else{}
        cout << "jeu = "<< jeu<<endl;
    }


//===================================================================================
//=============================Jeu terminé===========================================
//===================================================================================


    while (gagne != true || jeu!= false);
    //while(jeu != false);
   //while (jeu!=false || gagne == false);


    cout <<"Vous avez perdu !!!"<<'\n'<<endl;
    cout <<"Le mot a decouvrir etait : "<<'\t'<<mot_cache<<endl;

//===================================================================================
//=============================Fin du jeu============================================
//===================================================================================

}

//Méthode qui vérifie si le mot saisie pas l'utilisateur est le mot à deviner
void verification_mot(string &mot_cache,bool &gagne)
{

//===Défintion des variables locales===

    int choix,i;
    string mot;
    gagne = false;
    bool choix_jeu; //Booléen pour forcer le joueur a effectué un choix entre un et deux
//**********************************Réservé au test ************************************************//

    //cout << "mot cache : "<<'\t'<<mot_cache<<'\n'<<endl;


//**************************************************************************************************//


//***********************************Choix joueur *************************************************//

    cout << "Voulez vous proposez un mot suceptible d"<<'\''<<'\x88'<<"tre le mot cach\x82 ?"<<endl;

    cout << '\t' << "1_ Oui"<<endl;
    cout << '\t' << "2_ Non"<<endl;

    do
    {
        cin  >> i;
        cin.ignore();
        choix = i;


//===Mise a jour de choix_jeu===
        if(choix==1)
        {
            choix_jeu = true;
        }
        else
        {
            if(choix==2)
            {
                choix_jeu = true;
            }
            else
            {
                choix_jeu = false;
                cout << "Veuillez rentrez un choix entre 1 et 2"<<endl;
            }
        }
    }
//**************************************************************************************************//

    while(choix_jeu != true);
//***********************************Verification du mot********************************************//
    if (choix == 1) //Le joueur choisit de proposer un mot
    {
    //Saisie d'un mot à vérifier avec le mot caché

        cout << "Veuillez entrez un mot suceptible d etre le mot cache : \t";
        cin  >> mot;
        cout << endl;


    //Comparaison de la saisie utilisateur avec le mot caché


        if (mot.compare(mot_cache)!=0)
        //Cette opérateur renovie un valeur nulle si tous les caractères comparées sont identiques
        {
            cout << "Votre propositon n'est pas le mot \x85 deviner"<<endl;
        }


        else
        {
            cout << "Vous avez gagn\x82!"<<endl;
            cout << "Le mot \x85 deviner ""\x82""tait effectivement :\t"<<mot_cache<<endl;
            gagne=true;
            cout << "gagne = "<< gagne<<endl;
        }

    }
//**************************************************************************************************//




//***************************Le joueur ne propose pas de mot ***************************************//


   else
    {
        cout << "Vous pourrez proposer un mot plus tard"<<endl;
    }
//**************************************************************************************************//


    //system("cls");
}


//Méthode qui affecte le nombre de propositon disponible par le joueur selon le niveau de
//difficulté choisit
int niveau(int difficulte)
{
    afficher_entete();

    int i, proposition_joueur;

    cout << "Veuilllez entrez votre niveau de difficult\x82"":" << '\n'<<endl;
    cout << '\t'<<"1_ D""\x82""butant" << endl;
    cout << '\t'<<"2_ Interm""\x82""diaire"<< endl;
    cout << '\t'<<"3_ Expert"       << endl;
    cin>>i;
    cin.ignore();
    difficulte = i;

/* Boucle définissant le nombre de propositions*/
        if (difficulte == 1)
        {
         cout << "Vous avez choisit le niveau de difficulte Debutant" << endl;
         proposition_joueur = Debutant;
        }

        else
        {

            if (difficulte == 2)
            {
                cout << "Vous avez choisit le niveau de difficulte Intermediaire" << endl;
                proposition_joueur = Intermediaire;
            }

            else
            {
            cout << "Vous avez choisit le niveau de difficulte Expert" << endl;
            proposition_joueur = Expert;

            }
        }
        return   (proposition_joueur);
}

//Méthode qui affiche le graphique du pendu selon le nombre de proposition(s) restant(e)s
void afficher_pendu(int proposition_joueur)
{
	switch(proposition_joueur)
	{
	    case 9:
			cout << endl;
			cout << "              " << endl;
			cout << "              " << endl;
			cout << "              " << endl;
			cout << "              " << endl;
			cout << "              " << endl;
			cout << "              " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

	    case 8:
			cout << endl;
			cout << "              " << endl;
			cout << "              " << endl;
			cout << "              " << endl;
			cout << "        |      " << endl;
			cout << "        |      " << endl;
			cout << "        |      " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

	    case 7:
			cout << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

	    case 6:
			cout << endl;
			cout << "      --|     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

		case 5:
			cout << endl;
			cout << "     |--|     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

		case 4:
			cout << endl;
			cout << "     |--|     " << endl;
			cout << "     O  |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

		case 3:
			cout << endl;
			cout << "     |--|     " << endl;
			cout << "     O  |     " << endl;
			cout << "    /|  |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

		case 2:
				cout << endl;
			cout << "     |--|     " << endl;
			cout << "     O  |     " << endl;
			cout << "    /|\\ |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "        |     " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

		case 1:
			cout << endl;
			cout << "     |--|     " << endl;
			cout << "     O  |     " << endl;
			cout << "    /|\\ |     " << endl;
			cout << "     -  |     " << endl;
			cout << "    /   |     " << endl;
			cout << "        |     " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;

		case 0:
			cout << endl;
			cout << "     |--|     " << endl;
			cout << "     O  |     " << endl;
			cout << "    /|\\ |     " << endl;
			cout << "     -  |     " << endl;
			cout << "    / \\ |     " << endl;
			cout << "        |     " << endl;
			cout << "     ------   " << endl;
			cout << endl;
			break;
	}
}