Deuxieme programme en C, qu'en pensez-vous?

**beware** · 12/03/2009, 12h08

Bonjour,
après avoir publié mon premier programme ici il y a plus d'1 an, je me suis remis un peu à la programmation C.
N'ayant pas eu le temps entre les deux ni ne travaillant sur ce langage, mes connaissances n'ont que peu évoluer.

Pour ce deuxième programme, j'ai eu l'idée en suivant un tuto, c'est donc un simple jeu du pendu. Mais en le postant ici, j'espère que des plus doués que moi pourront y jeter un œil, même rapide, et me dire qu'elles sont mes erreurs. Merci d'avance à eux.

Voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
 
 
/* Defines */
#define TAILLE_MOT_MAX  10
#define OK              1
#define nOK             0
#define AFF_MENU        'm'
#define AFF_RESULTAT    'r'
#define AFF_REJOUER     'n'
 
/* Proptotypes des fonctions utilisees */
void tirage_motSecret(char *motSecret);
char saisie_caractere(int nb_coup, char *motJoue);
void test_lettre(char lettre, char *motSecret, char *motJoue);
int affichage(char type_affichage, int nb_coup_joue, char *motSecret, int etat_rejouer);
int rejouer(void);
 
 
int main(void) {
    /* Declaration des variables */
    int nb_coup_restant = 0;
    int nb_coup_joue = 0;
    int nb_coup_max = 0;
    int etat_rejouer = nOK;
    int indice_tableau = 0;
    char lettre;
    char *motJoue =  NULL;
    char type_affichage;
    char motSecret[TAILLE_MOT_MAX] = "";
 
    /* Initialisation de la fonction rand */
    srand(time(NULL));
 
    /* Le jeu se deroule tant que le joueur veut rejouer */
    do {
        /* Initialisation des variables */
        nb_coup_joue = 0;
        nb_coup_max = 0;
        nb_coup_restant = 0;
        etat_rejouer = nOK;
        indice_tableau = 0;
 
        /* On tire au hasard dans le fichier de mot disponible  */
        /* un mot secret a chaque nouvelle partie.              */
        tirage_motSecret(motSecret);
 
        /* Creation du tableau qui va permettre l'affichage */
        /* du mot joue par le joueur.                       */
        motJoue = malloc(strlen(motSecret));
        if (motJoue == NULL)
            exit(0);
 
        /* On remplit le tableua motJoue avec le caractére '*'  */
        /* et le caractere de fin '\0'                          */
        while (indice_tableau < strlen(motSecret)) {
            motJoue[indice_tableau] = '*';
            indice_tableau++;
        }
        motJoue[indice_tableau] = '\0';
 
        /* Affichage du menu */
        type_affichage = AFF_MENU;
        nb_coup_max = affichage(type_affichage, nb_coup_joue, motSecret, etat_rejouer);
        nb_coup_restant =  nb_coup_max;
 
 
        /* La boucle s'effectue tant qu'il reste des coups a jouer  */
        /* ou tant qu'il reste des lettre non trouvees. */
        do {
            /* On recupere la lettre du joueur */
            lettre = saisie_caractere(nb_coup_restant, motJoue);
 
            /* On teste la presence de cette lettre dans le mot mystere */
            test_lettre(lettre, motSecret, motJoue);
 
            /* On  enleve 1 coup */
            nb_coup_restant--;
        }
        while ((strchr(motJoue, '*') != NULL) && (nb_coup_restant > 0));
 
        /* Definition du resultat :                                                */
        /* nb_coup_joue = -1                            si le mot reste introuvé   */
        /* nb_coup_joue = nb_coup_max - nb_coup_restant si le mot est trouvé       */
        type_affichage = AFF_RESULTAT;
        if (strchr(motJoue, '*') != NULL) {
            nb_coup_joue = -1;
        }
        else {
            nb_coup_joue = nb_coup_max - nb_coup_restant;
        }
        affichage(type_affichage, nb_coup_joue, motSecret, etat_rejouer);
 
        /* On demande au joueur s'il veut rejouer */
        /* On affiche un message en fonction de la reponse */
        etat_rejouer = rejouer();
        type_affichage = AFF_REJOUER;
        affichage(type_affichage, nb_coup_joue, motSecret, etat_rejouer);
 
    }
    while(etat_rejouer == OK);
 
    /* On libere le pointeur motJoue */
    free(motJoue);
 
 
    return 0;
}
 
char saisie_caractere(int nb_coup_restant, char *motJoue) {
 
 
    /* Declaration variables de la fonction */
    char lettre_joue;
    char saisie[5];
    int etat_saisie = 0;
    int indice_tableau = 0;
    int ret = 0;
 
    /* Affichage du nombre de coup restant et du mot mystere    */
    /* avec les lettres deja decouvertes par le joueur          */
    printf("\nIl vous reste %d coups a jouer", nb_coup_restant);
    printf("\nQuel est le mot secret?");
 
    while (motJoue[indice_tableau] != '\0') {
        printf(" %c", motJoue[indice_tableau]);
        indice_tableau++;
    }
 
    do {
        printf("\nProposez une lettre : ");
 
        /* Sasie et extraction du chiffre de la chaine. */
        fgets(saisie, sizeof saisie, stdin);
        ret = sscanf(saisie, "%c", &lettre_joue);
 
        /* Verification de validite de la saisie */
        if (ret != 1) {
            printf( "\n\t La valeur entree n'est pas une donne valide."
                    "\n\t Veuillez recommencer.\n");
        }
        /* Verification que le caractere est une lettre */
        else if (isalpha(lettre_joue) != 0) {
            etat_saisie = OK;
        }
        else {
            printf( "\n\t Le caractere saisi n'est pas une lettre. Seuls"
                    "\n\t les lettres de l'alphabet sont autorisees.");
        }
    }
    while(etat_saisie != OK);
 
 
        /* On retourne la lettre saisie en majuscule */
        return (toupper(lettre_joue));
}
 
void test_lettre(char lettre, char *motSecret, char *motJoue) {
 
    int indice_tableau = 0;
 
    while (indice_tableau <= strlen(motSecret)) {
        if (lettre == motSecret[indice_tableau])
            motJoue[indice_tableau] = lettre;
        indice_tableau++;
    }
}
 
int affichage(char type_affichage, int nb_coup_joue, char *motSecret, int etat_rejouer) {
 
    char saisie[4];
    int ret = 0;
    int choix_niveau = 0;
    int etat_saisie = nOK;
 
    /* On choisit ce qu'il faut afficher */
    switch(type_affichage) {
        /* affichage du menu */
            case AFF_MENU :     printf( "\n\t ################################"
                                        "\n\t ##                            ##"
                                        "\n\t ##        JEU DU PENDU        ##"
                                        "\n\t ##        ------------        ##"
                                        "\n\t ##                            ##"
                                        "\n\t ################################");
                                printf( "\n\n");
                                printf( "\n\t Choisissez le niveau de difficulte :"
                                        "\n\t 1 - Niveau facile     : 10 coups"
                                        "\n\t 2 - Niveau moyen      : 9  coups"
                                        "\n\t 3 - Niveau difficile  : 8  coups"
                                        "\n\t 4 - Niveau hardcore   : 7  coups");
                                printf( "\n\n");
 
                                /* saisie du choix */
                                do {
                                    printf( "\n\t  Quel est votre choix ? ");
                                    fgets(saisie, sizeof(saisie), stdin);
                                    ret = sscanf(saisie, "%d", &choix_niveau);
 
                                    /* validation du choix */
                                    if (ret != 1) {
                                        printf( "\n\t Le choix n'est pas valide. Seuls les chiffres"
                                                "\n\t 1 a 4 sont acceptes.");
                                    }
                                    else if ((choix_niveau < 1) || (choix_niveau > 4)) {
                                        printf( "\n\t Seuls les chiffres 1 a 4 sont acceptes");
                                    }
                                    else {
                                        etat_saisie = OK;
                                        printf( "\n\n"
                                                "Debut du jeu!!\n"
                                                "--------------"
                                                "\n\n");
                                    }
                                }
                                while (etat_saisie != OK);
 
                                /* attribution du nombre de coup max en fonction du niveau choisit */
                                switch (choix_niveau) {
                                    case 1  :   choix_niveau = 10;
                                                break;
                                    case 2  :   choix_niveau = 9;
                                                break;
                                    case 3  :   choix_niveau = 8;
                                                break;
                                    case 4  :   choix_niveau = 7;
                                                break;
                                    default :   break;
                                }
 
                                return (choix_niveau);
                                break;
 
 
        /* affichage du resultat suivant */
        case AFF_RESULTAT :     printf("\n\n");
                                if (nb_coup_joue < 0) {
                                    printf( "\n\t DOMMAGE !!!!"
                                            "\n\t Vous avez perdu. Le mot a trouver etait : %s", motSecret);
                                    printf("\n\n");
                                    return(0);
                                }
                                else {
                                    printf( "\n\t BRAVO !!!!!"
                                            "\n\t Vous avez trouve le mot mystere : %s en %d coups", motSecret, nb_coup_joue);
                                    printf("\n\n");
                                }
                                return(0);
                                break;
 
        case AFF_REJOUER :      printf("\n\n");
                                if (etat_rejouer == OK) {
                                    printf( "\n\t Le jeu va etre relance. Un nouveau mot secret"
                                            "\n\t va etre determine. Bonne chance.");
                                }
                                else {
                                    printf( "\n\t Merci d'avoir joue. A la prochaine.");
                                }
                                printf("\n\n");
                                return(0);
                                break;
 
 
            default         :   return(0);
                                break;
    }
}
 
int rejouer(void) {
 
    char saisie[4];
    int ret = 0;
    int etat_saisie = nOK;
    int choix_rejouer;
 
    do {
        /* affichage de la demande de rejouer */
        printf("\n\n");
        printf( "\n\t Voulez-vous rejouer?"
                "\n\t 1 - Oui"
                "\n\t 2 - Non"
                "\n\t Votre choix : ");
 
        /* saisie du choix */
        fgets(saisie, sizeof(saisie), stdin);
        ret = sscanf(saisie, "%d", &choix_rejouer);
 
        /* validite de la saisie */
        if (ret != 1) {
            printf( "\n\t La valeur saisie n'est pas valide. Seul les choix 1 et 2 "
                    "\n\t sont acceptees");
        }
        else if ((choix_rejouer < 1) || (choix_rejouer > 2)) {
            printf( "\n\t La valeur saisie n'est pas valide. Seul les choix 1 et 2 "
                    "\n\t sont acceptees");
        }
        else {
            etat_saisie = OK;
            /* On redefinit choix_rejouer suivant les etats OK et nOK   */
            /* respectivement pour rejouer et quitter                   */
            if (choix_rejouer == 1)
                choix_rejouer = OK;
            else
                choix_rejouer = nOK;
        }
    }
    while (etat_saisie != OK);
 
    return (choix_rejouer);
}
 
void tirage_motSecret(char *motSecret) {
 
    /* Declarations des variables */
    FILE *fichier = NULL;
    char *pointeur = NULL;
    int nb_mots_disponible = 0;
    int ligne_choisie = 0;
    int indice_ligne = 0;
 
    /* On ouvre le fichier en lecture seule */
    fichier = fopen("dico.txt", "r");
 
    /* On teste l'ouverture du fichier */
    if (fichier  != NULL) {
        /* le fichier est bien ouvert */
    }
    else {
        printf( "\n\t Le fichier dico.txt n'a pu etre ouvert."
                "\n\t Verifiez la presence ou l'intitule du fichier.");
        exit(0);
 
    }
 
    /* On compte le nombre de mot disponible */
    while (fgets(motSecret, TAILLE_MOT_MAX, fichier) != NULL) {
        nb_mots_disponible++;
    }
 
    /* On choisit une position au hasard */
    ligne_choisie = (rand() % (nb_mots_disponible - 1));
 
    /* On se repositionne sur la 1ere ligne */
    rewind(fichier);
 
    /* On lit les lignes jusqu'au numero choisie au hasard    */
    /* puis on stocke le mot present dans motSecret           */
    for (indice_ligne = 0; indice_ligne < ligne_choisie; indice_ligne++) {
        fgets(motSecret, TAILLE_MOT_MAX, fichier);
    }
    fgets(motSecret, TAILLE_MOT_MAX, fichier);
 
    /* On ferme le fichier */
    fclose(fichier);
 
    /* On doit retirer le caractére '\n' du mot secret */
    pointeur = strchr(motSecret, '\n');
    if (pointeur != NULL) {
        *pointeur = '\0';
    }
}

le fichier de mot est joint à ce message.

**beware** · 12/03/2009, 18h00

Petit changement :
- Je me suis aperçu que j'avais oublié le free() a la fin du programme aprés avoir utilisé un malloc.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
/* On libere le pointeur motJoue */
    free(motJoue);

**beware** · 13/03/2009, 17h56

Bon, j'ai encore apporté quelques modifications :

Dans le jeu
1. - on a la possibilité de quitter dans le menu rejouer et le menu principal
2. - on a la possibilité d'ajouter de nouveau mot dans le dictionnaire ou l'on tire les mots Secrets.
3. - le nombre de coup autoriser est détermine suivant la taille maximal des mots autorisé dans le dictionnaire (a revoir)
4. - au moment de rejouer, on a la possibilité de revenir au menu principal ou directement dans une partie
Dans le code
1. - on libere l'espace mémoire a la fin de chaque partie et non plus avant de quitter le programme.
2. - les prototypes des fonctions sont placés dans le header
3. - les defines sont placées dans le header

Voici le code pendu.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include "pendu.h"
 
 
 
int main(void) {
 
    /* Declaration des variables */
    int nb_coup_restant = 0;
    int nb_coup_joue = 0;
    int nb_coup_max = 0;
    int etat_rejouer = REJOUER_MENU;
    int indice_tableau = 0;
    int choix_menu = 0;
    char lettre;
    char *motJoue =  NULL;
    char motSecret[TAILLE_MOT_MAX] = "";
 
    /* Initialisation de la fonction rand */
    srand(time(NULL));
 
    /* Le jeu se deroule tant que le joueur veut rejouer */
    do {
 
        /* On affiche le menu principal au lancement du jeu, et ensuite     */
        /* a la demande du joueur, selon l'etat de la variable etat_rejouer */
        if (etat_rejouer == REJOUER_MENU) {
            /* Affichage du menu global :                                   */
            /* Ce menu permet de :                                          */
            /*  1 - lancer le jeu                                           */
            /*  2 - ajouter un nouveau mot mystere a la liste disponible    */
            /*  3 - quitter                                                 */
            choix_menu = affichage(AFF_GENERAL, nb_coup_joue, motSecret, etat_rejouer);
 
            /* Si le joueur choisit de rentrer un nouveau mystere on lance  */
            /* la fonction correspondante.                                  */
            if (choix_menu == 2) {
                nouveau_motSecret();
            }
            else if (choix_menu == 3) {
                affichage(AFF_REJOUER, nb_coup_joue, motSecret, QUITTER);
                return (0);
            }
        }
 
        /* Initialisation des variables */
        nb_coup_joue = 0;
        nb_coup_max = 0;
        nb_coup_restant = 0;
        etat_rejouer = nOK;
        indice_tableau = 0;
 
        /* On tire au hasard dans le fichier de mot disponible  */
        /* un mot secret a chaque nouvelle partie.              */
        tirage_motSecret(motSecret);
 
        /* Creation du tableau qui va permettre l'affichage */
        /* du mot joue par le joueur.                       */
        motJoue = malloc(strlen(motSecret));
        if (motJoue == NULL)
            exit(0);
 
        /* On remplit le tableua motJoue avec le caractére '*'  */
        /* et le caractere de fin '\0'                          */
        while (indice_tableau < strlen(motSecret)) {
            motJoue[indice_tableau] = '*';
            indice_tableau++;
        }
        motJoue[indice_tableau] = '\0';
 
        /* Affichage du menu */
        nb_coup_max = affichage(AFF_MENU_JEU, nb_coup_joue, motSecret, etat_rejouer);
        nb_coup_restant =  nb_coup_max;
 
 
        /* La boucle s'effectue tant qu'il reste des coups a jouer  */
        /* ou tant qu'il reste des lettre non trouvees. */
        do {
            /* On recupere la lettre du joueur */
            lettre = saisie_caractere(nb_coup_restant, motJoue);
 
            /* On teste la presence de cette lettre dans le mot mystere */
            test_lettre(lettre, motSecret, motJoue);
 
            /* On  enleve 1 coup */
            nb_coup_restant--;
        }
        while ((strchr(motJoue, '*') != NULL) && (nb_coup_restant > 0));
 
        /* Definition du resultat :                                                */
        /* nb_coup_joue = -1                            si le mot reste introuvé   */
        /* nb_coup_joue = nb_coup_max - nb_coup_restant si le mot est trouvé       */
        if (strchr(motJoue, '*') != NULL) {
            nb_coup_joue = -1;
        }
        else {
            nb_coup_joue = nb_coup_max - nb_coup_restant;
        }
        affichage(AFF_RESULTAT, nb_coup_joue, motSecret, etat_rejouer);
 
        /* On demande au joueur s'il veut rejouer */
        /* On affiche un message en fonction de la reponse */
        etat_rejouer = rejouer();
        affichage(AFF_REJOUER, nb_coup_joue, motSecret, etat_rejouer);
 
        /* On libere le pointeur motJoue */
        free(motJoue);
 
    }
    while((etat_rejouer == REJOUER_MENU) || (etat_rejouer == REJOUER_NORMAL));
 
    return 0;
}
 
char saisie_caractere(int nb_coup_restant, char *motJoue) {
 
 
    /* Declaration variables de la fonction */
    char lettre_joue;
    char saisie[5];
    int etat_saisie = 0;
    int indice_tableau = 0;
    int ret = 0;
 
    /* Affichage du nombre de coup restant et du mot mystere    */
    /* avec les lettres deja decouvertes par le joueur          */
    if (nb_coup_restant == 1) {
        printf("\nIl vous reste 1 coup a jouer");
    }
    else {
        printf("\nIl vous reste %d coups a jouer", nb_coup_restant);
    }
    printf("\nQuel est le mot secret? \t");
 
    while (motJoue[indice_tableau] != '\0') {
        printf(" %c", motJoue[indice_tableau]);
        indice_tableau++;
    }
 
    do {
        printf("\nProposez une lettre : ");
 
        /* Sasie et extraction du chiffre de la chaine. */
        fgets(saisie, sizeof saisie, stdin);
        ret = sscanf(saisie, "%c", &lettre_joue);
 
        /* Verification de validite de la saisie */
        if (ret != 1) {
            printf( "\n\t La valeur entree n'est pas une donne valide."
                    "\n\t Veuillez recommencer.\n");
        }
        /* Verification que le caractere est une lettre */
        else if (isalpha(lettre_joue) != 0) {
            etat_saisie = OK;
        }
        else {
            printf( "\n\t Le caractere saisi n'est pas une lettre. Seuls"
                    "\n\t les lettres de l'alphabet sont autorisees.");
        }
    }
    while(etat_saisie != OK);
 
 
        /* On retourne la lettre saisie en majuscule */
        return (toupper(lettre_joue));
}
 
void test_lettre(char lettre, char *motSecret, char *motJoue) {
 
    int indice_tableau = 0;
 
    while (indice_tableau <= strlen(motSecret)) {
        if (lettre == motSecret[indice_tableau])
            motJoue[indice_tableau] = lettre;
        indice_tableau++;
    }
}
 
int affichage(char type_affichage, int nb_coup_joue, char *motSecret, int etat_rejouer) {
 
    char saisie[4];
    int ret = 0;
    int choix_niveau = 0;
    int choix_menu = 0;
    int etat_saisie = nOK;
 
    /* On choisit ce qu'il faut afficher */
    switch(type_affichage) {
        /* affichage du menu */
            case AFF_MENU_JEU : printf("\n\n");
                                printf( "\n\t Choisissez le niveau de difficulte :"
                                        "\n\t 1 - Niveau facile     : %d coups"
                                        "\n\t 2 - Niveau moyen      : %d coups"
                                        "\n\t 3 - Niveau difficile  : %d coups"
                                        "\n\t 4 - Niveau hardcore   : %d coups"
                                        ,COUPS_FACILE, COUPS_MOYEN, COUPS_DIFFICILE, COUPS_HARDCORE);
                                printf( "\n\n");
 
                                /* saisie du choix */
                                do {
                                    printf( "\n\t  Quel est votre choix ? ");
                                    fgets(saisie, sizeof(saisie), stdin);
                                    ret = sscanf(saisie, "%d", &choix_niveau);
 
                                    /* validation du choix */
                                    if (ret != 1) {
                                        printf( "\n\t Le choix n'est pas valide. Seuls les chiffres"
                                                "\n\t 1 a 4 sont acceptes.");
                                    }
                                    else if ((choix_niveau < 1) || (choix_niveau > 4)) {
                                        printf( "\n\t Seuls les chiffres 1 a 4 sont acceptes");
                                    }
                                    else {
                                        etat_saisie = OK;
                                        printf( "\n\n"
                                                "Debut du jeu!!\n"
                                                "--------------"
                                                "\n\n");
                                    }
                                }
                                while (etat_saisie != OK);
 
                                /* attribution du nombre de coup max en fonction du niveau choisit */
                                switch (choix_niveau) {
                                    case 1  :   choix_niveau = 10;
                                                break;
                                    case 2  :   choix_niveau = 9;
                                                break;
                                    case 3  :   choix_niveau = 8;
                                                break;
                                    case 4  :   choix_niveau = 7;
                                                break;
                                    default :   break;
                                }
 
                                return (choix_niveau);
                                break;
 
 
        /* affichage du resultat suivant */
        case AFF_RESULTAT :     printf("\n\n");
                                if (nb_coup_joue < 0) {
                                    printf( "\n\t DOMMAGE !!!!"
                                            "\n\t Vous avez perdu. Le mot a trouver etait : %s", motSecret);
                                    printf( "\n\n");
                                    return(0);
                                }
                                else {
                                    printf( "\n\t BRAVO !!!!!"
                                            "\n\t Vous avez trouve le mot mystere : %s en %d coups", motSecret, nb_coup_joue);
                                    printf( "\n\n");
                                }
                                return(0);
                                break;
 
 
        /* affichage de la demande de rejouer */
        case AFF_REJOUER :      printf("\n\n");
                                if (etat_rejouer == REJOUER_NORMAL)
                                    printf( "\n\t Le jeu va etre relance. Un nouveau mot secret"
                                            "\n\t va etre determine. Bonne chance.");
                                else if (etat_rejouer == REJOUER_MENU)
                                    printf( "\n\t Le menu du jeu va s'afficher");
 
                                else
                                    printf( "\n\t Merci d'avoir joue. A la prochaine.");
 
                                printf("\n\n");
                                return(0);
                                break;
 
 
        /* affichage du menu general */
        case AFF_GENERAL :      printf( "\n\t ################################"
                                        "\n\t ##                            ##"
                                        "\n\t ##        JEU DU PENDU        ##"
                                        "\n\t ##        ------------        ##"
                                        "\n\t ##                            ##"
                                        "\n\t ################################");
                                printf( "\n\n");
                                printf( "\n\t Options disponibles : "
                                        "\n\t 1 - Lancer une partie"
                                        "\n\t 2 - Entrer un nouveau mystere dans le dictionnaire"
                                        "\n\t 3 - Quitter");
                                printf( "\n\n");
 
                                /* saisie du choix */
                                do {
                                    printf( "\n\t  Quel est votre choix ? ");
                                    fgets(saisie, sizeof(saisie), stdin);
                                    ret = sscanf(saisie, "%d", &choix_menu);
 
                                    /* validation du choix */
                                    if (ret != 1) {
                                        printf( "\n\t Le choix n'est pas valide. Seuls les chiffres"
                                                "\n\t 1, 2 et 3 sont acceptes.");
                                    }
                                    else if ((choix_menu < 1) || (choix_menu > 3)) {
                                        printf( "\n\t Seuls les chiffres 1, 2 et 3 sont acceptes");
                                    }
                                    else {
                                        etat_saisie = OK;
                                    }
                                }
                                while (etat_saisie != OK);
                                return(choix_menu);
                                break;
 
 
            /* valeur par defaut */
            default         :   return(0);
                                break;
    }
}
 
int rejouer(void) {
 
    char saisie[4];
    int ret = 0;
    int etat_saisie = nOK;
    int choix_rejouer;
 
    do {
        /* affichage de la demande de rejouer */
        printf("\n\n");
        printf( "\n\t Voulez-vous rejouer?"
                "\n\t 1 - Oui"
                "\n\t 2 - Oui, mais je veux retourner au menu d'abord"
                "\n\t 3 - Quitter"
                "\n\t Votre choix : ");
 
        /* saisie du choix */
        fgets(saisie, sizeof(saisie), stdin);
        ret = sscanf(saisie, "%d", &choix_rejouer);
 
        /* validite de la saisie */
        if (ret != 1) {
            printf( "\n\t La valeur saisie n'est pas valide. Seul les choix 1, 2 et 3 "
                    "\n\t sont acceptees");
        }
        else if ((choix_rejouer < 1) || (choix_rejouer > 3)) {
            printf( "\n\t La valeur saisie n'est pas valide. Seul les choix 1, 2 et 3 "
                    "\n\t sont acceptees");
        }
        else {
            etat_saisie = OK;
        }
    }
    while (etat_saisie != OK);
 
    /* on retourne le choix du joueur */
    return (choix_rejouer);
}
 
void tirage_motSecret(char *motSecret) {
 
    /* Declarations des variables */
    FILE *fichier = NULL;
    char *pointeur_pos = NULL;
    int nb_mots_disponible = 0;
    int ligne_choisie = 0;
    int indice_ligne = 0;
 
    /* On ouvre le fichier en lecture seule */
    fichier = fopen(FICHIER_MOT_SECRET, "r");
 
    /* On teste l'ouverture du fichier */
    if (fichier  != NULL) {
        /* le fichier est bien ouvert */
    }
    else {
        printf( "\n\t Le fichier dico.txt n'a pu etre ouvert."
                "\n\t Verifiez la presence ou l'intitule du fichier.");
        exit(0);
 
    }
 
    /* On compte le nombre de mot disponible */
    while (fgets(motSecret, TAILLE_MOT_MAX, fichier) != NULL) {
        nb_mots_disponible++;
    }
 
    /* On choisit une position au hasard */
    ligne_choisie = (rand() % (nb_mots_disponible - 1));
 
    /* On se repositionne sur la 1ere ligne */
    rewind(fichier);
 
    /* On lit les lignes jusqu'au numero choisie au hasard    */
    /* puis on stocke le mot present dans motSecret           */
    for (indice_ligne = 0; indice_ligne < ligne_choisie; indice_ligne++) {
        fgets(motSecret, TAILLE_MOT_MAX, fichier);
    }
    fgets(motSecret, TAILLE_MOT_MAX, fichier);
 
    /* On ferme le fichier */
    fclose(fichier);
 
    /* On doit retirer le caractére '\n' du mot secret */
    pointeur_pos = strchr(motSecret, '\n');
    if (pointeur_pos != NULL) {
        *pointeur_pos = '\0';
    }
}
 
void nouveau_motSecret(void) {
 
    /* declaration des variables */
    FILE *fichier = NULL;
    char saisie[15];
    char *pointeur_pos = NULL;
    int indice_chaine = 0;
    int validite_saisie;
 
    do {
        /* initialisation de la validite de la saisie */
        validite_saisie = OK;
        /* Saisie du nouveau mot */
        printf( "\n\n"
                "\n\t .........................................................."
                "\n\t . Veuillez saisir le nouveau mot que vous voulez inserer ."
                "\n\t . dans le dictionnaire de mot secret. La taille du mot   ."
                "\n\t . est limite a 10 caracteres.                            ."
                "\n\t .........................................................."
                "\n\t Nouveau mot : ");
 
        fgets(saisie, sizeof(saisie), stdin);
 
        /* On doit retirer le caractére '\n' du mot secret */
        pointeur_pos = strchr(saisie, '\n');
        if (pointeur_pos != NULL) {
            *pointeur_pos = '\0';
        }
 
        /* On verifie la saisie :                                                                                   */
        /* - le mot ne doit pas faire plus de 10 caractere                                                          */
        /* - le mot ne doit pas comporter de chiffre, d'espace ou de caractere autre que les lettres de l'alphabet  */
        if (strlen(saisie) > TAILLE_MOT_MAX + 1) {
            printf( "\n\t Le mot entre est trop long. Il ne doit pas exceder"
                    "\n\t 10 caractere.");
            validite_saisie = nOK;
        }
 
        /* On parcourt la chaine pour verifier qu'il n'y a que des caracteres alphabetiques.    */
        /* Si le caractere est alphabetique on le met en majuscule                              */
        indice_chaine = 0;
        while ((indice_chaine < strlen(saisie)) && (validite_saisie != nOK)) {
            if (isalpha(saisie[indice_chaine]) == 0) {
                validite_saisie = nOK;
                printf( "\n\t La saisie comprend des caracteres autres que des lettres de l'alphabet.");
            }
            else {
                saisie[indice_chaine] = toupper(saisie[indice_chaine]);
            }
            indice_chaine++;
        }
    }
    while (validite_saisie != OK);
 
    /* On ouvre le fichier en mode ajout */
    fichier = fopen(FICHIER_MOT_SECRET, "a");
 
    /* On teste l'ouverture du fichier */
    if (fichier  != NULL) {
        /* le fichier est bien ouvert */
    }
    else {
        printf( "\n\t Le fichier dico.txt n'a pu etre ouvert."
                "\n\t Verifiez la presence ou l'intitule du fichier.");
        exit(0);
    }
 
    /* On ajoute le nouveau mot */
    fprintf(fichier, "%s\n", saisie);
 
    /* On referme le fichier */
    fclose(fichier);
 
}

et le fichier pendu.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#ifndef PENDU_H_INCLUDED
#define PENDU_H_INCLUDED
 
/* defines */
/* Defines */
#define TAILLE_MOT_MAX      10
#define OK                  1
#define nOK                 0
#define AFF_MENU_JEU        'm'
#define AFF_RESULTAT        'r'
#define AFF_REJOUER         'n'
#define AFF_GENERAL         'g'
#define FICHIER_MOT_SECRET  "dico.txt"
#define REJOUER_NORMAL      1
#define REJOUER_MENU        2
#define QUITTER             3
#define COUPS_FACILE        (TAILLE_MOT_MAX + 3)
#define COUPS_MOYEN         (TAILLE_MOT_MAX + 2)
#define COUPS_DIFFICILE     (TAILLE_MOT_MAX + 1)
#define COUPS_HARDCORE      TAILLE_MOT_MAX
 
 
 
/* Proptotypes des fonctions utilisees */
void tirage_motSecret(char *motSecret);
char saisie_caractere(int nb_coup, char *motJoue);
void test_lettre(char lettre, char *motSecret, char *motJoue);
int affichage(char type_affichage, int nb_coup_joue, char *motSecret, int etat_rejouer);
int rejouer(void);
void nouveau_motSecret(void);
 
#endif // PENDU_H_INCLUDED

**Nival** · 13/03/2009, 18h18

Euh... Je suis débutant en C mais malgré tout je doute que quiconque viendra analyser ton code dans le détail pour y chercher une éventuelle maladresse d'écriture, c'est un travail assez ingrat...

En revanche j'ai compilé ton prog, il marche donc c'est déjà un bon début

, techniquement ça semble bien rodé, il y a des sécurités un peu partout pour éviter les erreurs engendrés par l'utilisateur (saisis invalides).

En revanche il y a un "bug" du moins par rapport aux vraies règles du pendu:
dans ton prog on perd un coup même si on donne une lettre correcte, mais peut-ête est-ce voulu? Cependant de ce fait, même si on devine le "mot mystère", on peut parfois ne pas pouvoir "gagner" car on a plus assez de coup pour rentrer toutes les lettres manquantes...

Par ailleurs (et pour corser un peu le défi

), 2 améliorations seraient à mon avis bienvenues:

1- enrichir le dico! Tu peux notamment utiliser des listes trouvables sur Internet (dico pour Scrabble ou mots croisés p.ex.), mais il faudra parfois faire des "aménagement": ainsi cette liste contient la nature et le nombre d'occurrences à la suite de chaque mot, mais tu peux sans trop de difficulter créer un programme qui te la convertira en suite simple de mot, p.ex. en supprimant les chiffres et un certain nombre de mots prédéfinis (adj., subst., ...), ou bien encore en n'incluant dans ton dico qu'une suite de caractères sur 3 ; cette autre liste contient des mots plus intéressants (la première étant une liste des mots "las plus courants") et est directement exploitable, si ce n'est qu'elle contient des formes conjuguées des verbes...
Bref, un bon exercice complémentaire en perspective!

2- améliorer l'interface, p.ex. en réinitialisant la console à chaque nouvelle entrée pour éviter les lignes successives, et en profiter pour maintenir à jour dans un coin la liste des lettres déjà demandées, et par là même prévenir si une lettre a déjà été proposée (facile ça

), et puis pourquoi pas "dessiner" le ptit bonhomme qui se fait pendre avec des caractères...

EDIT:

Code console :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
  #########
   ##    |
   ##   .|',! 
   ##  ` O__
   ##   /\\
   ##     |\
   ##      
   ##
########

**beware** · 14/03/2009, 10h45

Envoyé par Nival

Euh... Je suis débutant en C mais malgré tout je doute que quiconque viendra analyser ton code dans le détail pour y chercher une éventuelle maladresse d'écriture, c'est un travail assez ingrat...

Oui, tu as raison. Je pensais que c'était une bonne idée pour avoir une idée si ce que je faisais était correct et corriger certaines erreurs grossières. Mais effectivement, c'est un travail ingrat.

Envoyé par Nival

En revanche j'ai compilé ton prog, il marche donc c'est déjà un bon début

, techniquement ça semble bien rodé, il y a des sécurités un peu partout pour éviter les erreurs engendrés par l'utilisateur (saisis invalides).

C'est effectivement un bon début qu'il compile

.

Envoyé par Nival

En revanche il y a un "bug" du moins par rapport aux vraies règles du pendu:
dans ton prog on perd un coup même si on donne une lettre correcte, mais peut-ête est-ce voulu? Cependant de ce fait, même si on devine le "mot mystère", on peut parfois ne pas pouvoir "gagner" car on a plus assez de coup pour rentrer toutes les lettres manquantes...

Merci, c'est noté. Encore une fois tu as raison (mais que ca devienne pas une habitude

, j'ai pas intégré cette règle basique.

Envoyé par Nival

Par ailleurs (et pour corser un peu le défi

), 2 améliorations seraient à mon avis bienvenues:

1- enrichir le dico! Tu peux notamment utiliser des listes trouvables sur Internet (dico pour Scrabble ou mots croisés p.ex.), mais il faudra parfois faire des "aménagement": ainsi cette liste contient la nature et le nombre d'occurrences à la suite de chaque mot, mais tu peux sans trop de difficulter créer un programme qui te la convertira en suite simple de mot, p.ex. en supprimant les chiffres et un certain nombre de mots prédéfinis (adj., subst., ...), ou bien encore en n'incluant dans ton dico qu'une suite de caractères sur 3 ; cette autre liste contient des mots plus intéressants (la première étant une liste des mots "las plus courants") et est directement exploitable, si ce n'est qu'elle contient des formes conjuguées des verbes...
Bref, un bon exercice complémentaire en perspective!

2- améliorer l'interface, p.ex. en réinitialisant la console à chaque nouvelle entrée pour éviter les lignes successives, et en profiter pour maintenir à jour dans un coin la liste des lettres déjà demandées, et par là même prévenir si une lettre a déjà été proposée (facile ça

), et puis pourquoi pas "dessiner" le ptit bonhomme qui se fait pendre avec des caractères...

EDIT:

Code console :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
  #########
   ##    |
   ##   .|',! 
   ##  ` O__
   ##   /\\
   ##     |\
   ##      
   ##
########

Merci encore une fois, pour toutes ces propositions. Il faut que je les intègrent dans mon code. Ca me tiendra un peu de temps.

**LittleWhite** · 15/03/2009, 00h45

Bonjour,

J'ai pas regardé le code ( ou pas encore )
Première chose de bien, valgrind ne semble pas dire qu'il y ai de fuite de mémoire. ( valgrind est un programme qui surveille les allocations désallocations ).
Par contre , j'ai un bug.
Voici la sortie de mon terminal :

Il vous reste 3 coups a jouer
Quel est le mot secret? V E R * *
Proposez une lettre : t

Il vous reste 2 coups a jouer
Quel est le mot secret? V E R T *
Proposez une lettre : e

Il vous reste 1 coups a jouer
Quel est le mot secret? V E R T *
Proposez une lettre : u

DOMMAGE !!!!
Vous avez perdu. Le mot a trouver etait : VERT

Voulez-vous rejouer?
1 - Oui
2 - Non
Votre choix :

Tu remarquera rapidement qu'il y a une étoile en trop pour le mot ... :s

Après, tu peux commencer à te lancer dans un projet avec plusieurs fichiers sources. ( Pour alléger le fichier de code :p , et pour que se soit plus simple à gérer ) ( fichier .h pour les déclarations ( les prototypes que tu as mis au dessus du main ) , et .c pour le code à proprement parler ). Tu verra aussi la notion de makefile en passant.

En parcourant le code vite fait, je n'ai pas vu de grosse abération

**beware** · 19/03/2009, 11h54

Bonjour,

merci pour ta réponse, et désolé d'avoir été si long.
Bon, après moult changements, je crois que desormais le code est plus efficace.

Je ne met pas directement le code ici ca risquerait d'etre peu lisible, cependant si vous etes interesse il est disponible ici :

http://beware007.free.fr/Projet_C/Pendu/

Deuxieme programme en C, qu'en pensez-vous?

C

Discussions similaires

Partager

Partager