1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
QCoreApplication a(argc, argv);
MaClasse appelClasse;
/*
transform(s.begin(), s.end(), s.begin(), my_tolower()); //Commande pour convertir les mots ou lettres en minuscules
cout << s; // affiche "abcdef"
transform(s.begin(), s.end(), s.begin(), my_toupper());//Commande pour convertir les mots ou lettres en majuscules
cout << s; // affiche "ABCDEF"
*/
/************************************************************************************************************/
/* DECLARATION DES VARIABLES */
/************************************************************************************************************/
char rejouer;
string leMot, leMotMelange, motUtilisateur, joueur, pourIndice ;
int compteurRejouer(0), compteurTrouveMot(0);
unsigned int numeroLigne; //un entier non signé pour être sûr qu'on puisse atteindre les 300 000 mots, voir plus avec un dico modifié...
vector <string> tableauDico; //Un tableau dynamique pour stocker tous les mots du dicos (plus de 300000 !!!!)
vector <string> tableauPhrases; //Un tableau dynamique pour stocker tous les phrases à choisir pour répondre toutes les fois que le joueur à faux
string ligne; //Pour récupérer chaque ligne
/************************************************************************************************************/
/* INITIALISER LE GENERATEUR DE NOMBRE ALEATOIRE*/
/************************************************************************************************************/
srand(time(NULL));
/************************************************************************************************************/
/* COMMENCE LE PROGRAMME */
/************************************************************************************************************/
cout << "Ah que c'est quoi ton prenom mec ? " << endl;
cin >> joueur;
transform(joueur.begin(), joueur.end(), joueur.begin(), my_toupper());//Met le nom en majuscule
cout << "C'est ca ton prenom ? " << joueur <<" ! ! ! Phfffffffffooooouuuuu Wouaaaaaaa ha ha ha ha ha ha ! \nBon c'est pas grave, on va faire avec hein... Bien oblige de toute facon..." << endl;
/************************************************************************************************************/
/* OUVERTURE DU FICHIER TEXTE*/
/************************************************************************************************************/
ifstream dico("dico.txt");
/************************************************************************************************************/
/* RECUPERATION DE TOUTES LES LIGNES DU FICHIER TEXTE DANS UN TABLEAU */
/************************************************************************************************************/
if (dico) //La condition pour le cas où il n'y aurait pas de fichier texte
{
while (getline(dico,ligne))
{
tableauDico.push_back(ligne); //On met les lignes dans le tableau.
}
/************************************************************************************************************/
/* BOUCLE POUR DONNER LA POSSIBLITE AU JOUR DE REJOUER S'IL LE DESIRE */
/************************************************************************************************************/
do
{
/************************************************************************************************************/
/* COMPTE LE NOMBRE DE FOIS QUE LE JOUEUR REJOUE*/
/************************************************************************************************************/
compteurRejouer ++;
compteurRejouer -= 1;
/************************************************************************************************************/
/* RECUPERER UN MOT DANS LE TABLEAU */
/************************************************************************************************************/
// Récupérer un mot aléatoire du tableau
numeroLigne = rand () % tableauDico.size(); //Choisir un numéro au hasard plus petit que la taille du tableau.
leMot = tableauDico[numeroLigne]; //On met dans mot, le mot trouvé dans le tableau à la case numéroLigne.
transform(leMot.begin(), leMot.end(), leMot.begin(), my_toupper());//Met le mot en majuscule
/************************************************************************************************************/
/* MELANGER LES LETTRE */
/************************************************************************************************************/
leMotMelange = appelClasse.melangeLeMot(leMot);//Mélange le mot
/************************************************************************************************************/
/* MET EN PLACE LES TIRETS POUR LES INDICES */
/************************************************************************************************************/
pourIndice = appelClasse.donneDesIndices(leMot);
/************************************************************************************************************/
//DEMANDE AU JOUEUR DE REMETTRE EN PLACE LES LETTRES DU MOT A TROUVER */
/************************************************************************************************************/
cout << "\nBon allez au boulot " << joueur << " Remets-moi ce mot en place stp << " << leMotMelange << " >>" << endl;
cin >> motUtilisateur;
/************************************************************************************************************/
/* BOUCLE DE COMPARAISON DU MOT A TROUVER ET REJOUER TANT QUE LE JOUEUR NE L'AURA PAS TROUVE */
/************************************************************************************************************/
do
{
/************************************************************************************************************/
/* COMPTE EN COMBIEN DE COUPS LE MOT SERA TROUVE*/
/************************************************************************************************************/
compteurTrouveMot++;
/************************************************************************************************************/
/* MET LE MOT EN MAJUSCULE*/
/************************************************************************************************************/
transform(motUtilisateur.begin(), motUtilisateur.end(), motUtilisateur.begin(), my_toupper());//Met le mot en majuscule
/************************************************************************************************************/
/* SI LE MOT EST TROUVE */
/************************************************************************************************************/
if (motUtilisateur == leMot)
{
cout << "\nOuais super " << joueur << " ! C'est bien le mot qu'il fallait trouver" << endl;
cout << " Bon qu'est-ce que tu veux faire ? Tu rejoues ? O/N" << endl;
cin >> rejouer;
}
/************************************************************************************************************/
/* SI LE MOT N'EST PAS TROUVE */
/************************************************************************************************************/
else
{
string laPhrasesChoisie;
int numeroPhrase(0);
string lettreAAfficher;
/************************************************************************************************************/
/* OUVERTURE DU FICHIER TEXTE DANS LEQUEL LE PROGRAMME TROUVERA
QUELQUES PHRASES NEGATIVES A AFFICHER AU HAZARD*/
/************************************************************************************************************/
ifstream dicoPhrases("PhrasesChoisies.txt");
/************************************************************************************************************/
/* RECUPERATION DE TOUTES LES LIGNES DU FICHIER TEXTE DANS UN TABLEAU */
/************************************************************************************************************/
if (dicoPhrases) //La condition c'est pour le cas où il n'y aurait pas de fichier texte
{
while (getline(dicoPhrases,ligne))//Tant que trouve des lignes
{
tableauPhrases.push_back(ligne); //les copier dans le tableau.
}
/************************************************************************************************************/
/* RECUPERER UNE PHRASE DANS LE TABLEAU */
/************************************************************************************************************/
// Récupérer une phrase aléatoire du tableau
numeroPhrase = rand () % tableauPhrases.size(); //Choisir un numéro au hasard plus petit que la taille du tableau.
laPhrasesChoisie = tableauPhrases[numeroPhrase]; //et placer la phrase qui se trouve à cet emplacemet, dans la variable "laPhraseChoisie"
}
else
{
cout << "Je ne peux pas ouvrir le fichier << PhrasesChoisies >>, je ne le trouve pas ";// Si le fichiers des phrases choisies ne se trouve pas dans le bon répertoire
// ou s'il a disparu, le prog l'affiche.
}
int const nbLettreDansMot(leMot.size());
if (nbLettreDansMot == compteurTrouveMot)
{
cout << "Perdu il n'y a plus de lettres dans le mot a trouver" << endl;
cout << "Le mot a trouver etait " << leMot << endl;
cout << " Bon qu'est-ce que tu veux faire ? Tu rejoues ? O/N" << endl;
cin >> rejouer;
compteurTrouveMot = 0;//Réinitialise ce compteur
break;
}
else
{
/************************************************************************************************************/
/* AFFICHE POUR LE JOUEUR SON MAUVAIS CHOIX ET L'INVITE A REFAIRE UN NOUVEAU CHOIX */
/************************************************************************************************************/
cout << laPhrasesChoisie << " ";
cout << endl << "Allez ! Recommence..." << " << " << leMotMelange << " >>" << endl;
cout << "\nTiens pour t'aider un brin, voici un indice... " ;
lettreAAfficher= appelClasse.choixLettreIndice(leMot, leMotMelange, pourIndice);//Va chercher une nouvelle lettre pour aider le joueur
pourIndice = lettreAAfficher;// "pourIndice" doit prendre la configuration actuelle pour le prochain coup
cout << " << " << lettreAAfficher << " >> en " << appelClasse.emplacementTirets << endl;//Affiche les tirets ainsi que la nouvelle lettre comme aide pour trouver le mot
cout << endl << "Nombre de coups : [ " << compteurTrouveMot << " ]" << endl;
cin >> motUtilisateur;
}
}
/************************************************************************************************************/
/* FIN DE LA BOUCLE DE COMPARAISON DU MOT */
/************************************************************************************************************/
}while (motUtilisateur != leMot);
/************************************************************************************************************/
/* FIN DE A BOUCLE REJOUER */
/************************************************************************************************************/
}while (rejouer == 'o');//Tant que le joueur veut rejouer alors on continue
cout << endl << "\nAlors si tu veux plus jouer bye " << joueur << " !" << endl;// Fin du jeu
}
else
{
cout << " \n\nJe ne trouve pas le fichier (dico.txt) " << endl;
}
return a.exec();// C'est ici que le pro en compilant coince... |
petit souci expected
Répondre avec citation
Partager