Discussion :

[Rodrig0]

Salut a tous je suis débutant en langage c et pour un projet d'algo on doit réaliser un jeu de mastermind. J'arrive à lancer mon programme mais celui ci ne marche pas correctement, par exemple quand je rentre une combinaison de chiffres non valide ( trop de chiffres) il ne fait aucune différence et indique toujours 0 pions bien placés et 0 pions mal placés. Je pense que cela vient de gets dans jeu.c qui au début était cgets mais compil impossible.

J'espère que vous pourrez m'aider.
Le code:

main.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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include<conio.h>
 
#include "jeu.h"
#include "constantes.h"
 
 
 
void main(void)   // gestion de la partie
{
    int combi_secret[NPOS]; //combinaison secrète tirée par le programme
    int prop[NPOS];//proposition du joueur
    int nbrcoup;// compte le nombre de coups joués
    int bpos;//nombre de chiffres exacts et bien placés
    int bchif;//nombre de chiffres exacts mais mal placés
    int i,ok=0;
 
    intro_txt();
    tirage_aleatoire(combi_secret); //tirage aléatoire de la combinaison     secrète
    nbrcoup=0;
 
    do{
        while(!ok)
        {
            printf("\n Entrez une combinaison:\n");
            if(combi_entree_par_joueur(&prop))   //jai rajouter le ==0  c'est que la proposition est correcte
            {
                ok=1;
            }
            else
            {
                printf("\nProposition incorecte !Entrez une autre combinaison .\n");
            }
        }
        analyse_combi_saisie(prop,combi_secret,&bpos,&bchif);   // on est sorti de la boucle car ok=1 > combinaison valide
        printf("\n%22d P %dC\n",bpos,bchif);
        nbrcoup++;   // on incrémente le nbr d'essai
    }
    while((bpos< NPOS) && (nbrcoup <NCMAX));  //condition de sortie de la boucle
 
    if(bpos==NPOS)
    {
        printf("\nVous avez trouve la combinaison secrete en %d coups", nbrcoup);
    }
    else
    {
        printf("\nVous n'avez pas trouve en %d coups.\n", NCMAX);
        printf("\nLa bonne combinaison etait: ");
        for(i=0;i<NPOS;i++)
        {
            printf("%d",combi_secret[i]);
        }
        printf("\n\n\n");
    }
}

jeu.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
void tirage_aleatoire(int tir[NPOS]) // on passe en parametres un tab de int contenant la solution: on la modifie
{
 
    int i;
    srand(time(NULL));  //init de random
    for(i=0; i< NPOS; i++)
    {
         tir[i]= rand() / (RAND_MAX +1.) * NCHIF +1;
         //tir[i]=rand()%RAND_MAX;
    }
}
 
//Fonction de lecture de la proposition du joueur avec controle de validité et conversion char[]>>int []
 
int combi_entree_par_joueur(int prop[NPOS])
{
    char ch[NPOS+3]; // chaine ou sera lue la proposition du joueur:on fait de la place en + : 3 cases en plus dans chaine de caract ( [0] nbr max de caract a entrer,\0, [2]nbr caract reel de la chaine)
    int i;
 
    //lecture proposition du joueur dans chaine ch
    ch[0]=NPOS+1;  // +1 car on compte en plus le \0 :: Préparation longueur max chaine lue
    gets(ch);     //la fonction lit les 6 caractères rentrés: pas plus>      SANS CGETS ca a l'air de marcher
 
    //controles
    if(strlen(&ch[2]) != NPOS)    //fonction type: strlen(char* ) : compte le nbr de caractères de ch;  or char ch[NPOS] = char* ch : tableau de char
    {                     //pas compris &ch[2]   jaurai mis [1] ?????
        return -1;        //on a pas autant de chiffres: de caract que de cases dans le jeu > entree incorecte direct
    }
    for(i=2; i<NPOS+2;i++)  // car en NPOS+3  c'est \0
    {
        if(ch[i] < '1' || ch[i]> '1'+NCHIF-1)
        {           //val:49
            return -1;  //reponse invalide
        }
    }
 
    //extraction des chiffres entres au clavier : conversion char[]>> int[]
    for(i=0; i<NPOS;i++)
    {
        prop[i]=ch[2+i] -'0';  // on met l'essai du joueur dans int prop[]
    }
    return 0;   //reponse valide
}
 
//Fonction d'analyse de la proposition du joueur: indique les chiffres exacts bien placés ou non
 
void analyse_combi_saisie(int prop[], int combi_secret[],int bpos[], int bchif[])
{
    int combi_secret_BIS[NPOS];
    int i,j;
 
    for(i=0;i<NPOS;i++)
    {
        combi_secret_BIS[i]=combi_secret[i];  //copie de la combinaison secrète pour ne pas la modifier
    }
 
    //comptage des bons chiffres exacts et bien placés
    *bpos=0;
    for(i=0;i<NPOS;i++)
    {
        if(prop[i]==combi_secret_BIS[i])
        {
            (*bpos)++;  // incremente le nbr de chiffre exact et bien placés
            combi_secret_BIS[i]=prop[i]=0;  //alors on "supprime" cette valeur pour ne pas la recompter
        }
    }
 
    //Comptage bons chiffres  mais mal placés
    *bchif=0;
    for(i=0;i<NPOS;i++)
    {
        for(j=0;j<NPOS;j++)  //2eme boucle permet de se déplacer dans la combinaison secrète tiree via j , à i fixé sur la proposition du joueur
        {
            if(prop[i] != 0 && prop[i]==combi_secret_BIS[j])   // prop[i] != 0 c'est qu'on ne l'a pas compté comme exact et bien places > ok
            {
                (*bchif)++;
                prop[i]=combi_secret_BIS[j]=0; //alors on "supprime" cette valeur pour ne pas la recompter
            }
        }
    }
}

[Obsidian]

Tu peux éditer ton message à l'aide du bouton « Éditer » en bas à droite de la boîte qui contient ton message, et t'en servir pour encadrer ton code avec les balises [code] et [/code].

[Rodrig0]

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
constantes.h
#ifndef CONST_INCLUDED
#define CONST_INCLUDED
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <conio.h>
/*
constantes.h
Role: définit des constantes communes à tout le programme
*/
 
#define NPOS 5  //nombre de positions dans la plateforme de jeu
#define NCHIF 8 //nombre de chiffres correspondant aux couleurs: pour manipulation + facile
#define NCMAX 12 //nbr maximal de coups
 
 
#endif#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include<conio.h>
 
#include "jeu.h"
#include "constantes.h"
 
main.c
 
void main(void)   // gestion de la partie
{
    int combi_secret[NPOS]; //combinaison secrète tirée par le programme
    int prop[NPOS];//proposition du joueur
    int nbrcoup;// compte le nombre de coups joués
    int bpos;//nombre de chiffres exacts et bien placés
    int bchif;//nombre de chiffres exacts mais mal placés
    int i,ok=0;
 
    intro_txt();
    tirage_aleatoire(combi_secret); //tirage aléatoire de la combinaison secrète
    nbrcoup=0;
 
    do{
        while(!ok)
        {
            printf("\n Entrez une combinaison:\n");
            if(combi_entree_par_joueur(&prop))   //jai rajouter le ==0  c'est que la proposition est correcte
            {
                ok=1;
            }
            else
            {
                printf("\nProposition incorecte !Entrez une autre combinaison .\n");
            }
        }
        analyse_combi_saisie(prop,combi_secret,&bpos,&bchif);   // on est sorti de la boucle car ok=1 > combinaison valide
        printf("\n%22d P %dC\n",bpos,bchif);
        nbrcoup++;   // on incrémente le nbr d'essai
    }
    while((bpos< NPOS) && (nbrcoup <NCMAX));  //condition de sortie de la boucle
 
    if(bpos==NPOS)
    {
        printf("\nVous avez trouve la combinaison secrete en %d coups", nbrcoup);
    }
    else
    {
        printf("\nVous n'avez pas trouve en %d coups.\n", NCMAX);
        printf("\nLa bonne combinaison etait: ");
        for(i=0;i<NPOS;i++)
        {
            printf("%d",combi_secret[i]);
        }
        printf("\n\n\n");
    }
}
 
jeu.c
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <conio.h>
 
#include "jeu.h"
#include "constantes.h"
 
int intro_txt(void)
{
       printf("\n\n                    ----- MASTERMIND -----\n\n\
      L'ordinateur a genere une combinaison de %d chiffre alleatoire de 0 a %d.\n\
      A vous de les retrouver en essayant differentes combinaisons.\n\
      L'ordinateur indiquera a chaque fois un \"0\" pour un chiffre bien place\n\
      et une \"*\" pour un chiffre mal place.\n\n\n", NPOS, NCHIF);
 
      return 0;
}
 
//Fonction de tirage de la combinaison secrète
 
void tirage_aleatoire(int tir[NPOS]) // on passe en parametres un tab de int contenant la solution: on la modifie
{
 
    int i;
    srand(time(NULL));  //init de random
    for(i=0; i< NPOS; i++)
    {
         tir[i]= rand() / (RAND_MAX +1.) * NCHIF +1;
         //tir[i]=rand()%RAND_MAX;
    }
}
 
//Fonction de lecture de la proposition du joueur avec controle de validité et conversion char[]>>int []
 
int combi_entree_par_joueur(int prop[NPOS])
{
    char ch[NPOS+3]; // chaine ou sera lue la proposition du joueur:on fait de la place en + : 3 cases en plus dans chaine de caract ( [0] nbr max de caract a entrer,\0, [2]nbr caract reel de la chaine)
    int i;
 
    //lecture proposition du joueur dans chaine ch
    ch[0]=NPOS+1;  // +1 car on compte en plus le \0 :: Préparation longueur max chaine lue
    gets(ch);     //la fonction lit les 6 caractères rentrés: pas plus>      SANS CGETS ca a l'air de marcher
 
    //controles
    if(strlen(&ch[2]) != NPOS)    //fonction type: strlen(char* ) : compte le nbr de caractères de ch;  or char ch[NPOS] = char* ch : tableau de char
    {                     //pas compris &ch[2]   jaurai mis [1] ?????
        return -1;        //on a pas autant de chiffres: de caract que de cases dans le jeu > entree incorecte direct
    }
    for(i=2; i<NPOS+2;i++)  // car en NPOS+3  c'est \0
    {
        if(ch[i] < '1' || ch[i]> '1'+NCHIF-1)
        {           //val:49
            return -1;  //reponse invalide
        }
    }
 
    //extraction des chiffres entres au clavier : conversion char[]>> int[]
    for(i=0; i<NPOS;i++)
    {
        prop[i]=ch[2+i] -'0';  // on met l'essai du joueur dans int prop[]
    }
    return 0;   //reponse valide
}
 
//Fonction d'analyse de la proposition du joueur: indique les chiffres exacts bien placés ou non
 
void analyse_combi_saisie(int prop[], int combi_secret[],int bpos[], int bchif[])
{
    int combi_secret_BIS[NPOS];
    int i,j;
 
    for(i=0;i<NPOS;i++)
    {
        combi_secret_BIS[i]=combi_secret[i];  //copie de la combinaison secrète pour ne pas la modifier
    }
 
    //comptage des bons chiffres exacts et bien placés
    *bpos=0;
    for(i=0;i<NPOS;i++)
    {
        if(prop[i]==combi_secret_BIS[i])
        {
            (*bpos)++;  // incremente le nbr de chiffre exact et bien placés
            combi_secret_BIS[i]=prop[i]=0;  //alors on "supprime" cette valeur pour ne pas la recompter
        }
    }
 
    //Comptage bons chiffres  mais mal placés
    *bchif=0;
    for(i=0;i<NPOS;i++)
    {
        for(j=0;j<NPOS;j++)  //2eme boucle permet de se déplacer dans la combinaison secrète tiree via j , à i fixé sur la proposition du joueur
        {
            if(prop[i] != 0 && prop[i]==combi_secret_BIS[j])   // prop[i] != 0 c'est qu'on ne l'a pas compté comme exact et bien places > ok
            {
                (*bchif)++;
                prop[i]=combi_secret_BIS[j]=0; //alors on "supprime" cette valeur pour ne pas la recompter
            }
        }
    }
}

[LittleWhite]

Bonjour,

Tout d'abord gets() est déprécié ! pour des raisons de faille de sécurité ! Donc feuillez le remplacer par fgets(). Merci.

Maintenant, pour votre problème, je vous conseille de vous amusez avec un debuggueur. Le debuggueur vous permettra d'executer le programme pas à pas pour surveiller ce qu'il fait, ainsi que de regarder le contenu des variables (que des trucs pratique dans le debuggueur). Comme vous en aurez besoin toute votre vie de programmeur, je vous conseille d'apprendre à l'utiliser maintenant

[Rodrig0]

Merci pour le tuyau, mon programme fonctionne un peu mieux mais il reste encore 2 3 trucs a régler.
Sinon j'ai développer aussi une interfacez graphique en SDL pour le jeu. Seulement à la compilation jai ces erreurs et je ne les comprends, pourriez vous m'aider svp ?

main.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
#ifdef HAVE_CONFIG_H    /*#ifdef pour dire "Si la constante est définie"   :HAVE_CONFIG_H .*/
#include <config.h>     /*les '<' et '>' indique que le compilateur ( enfin le préprocesseur pour être précis ) doit regarder dans les répertoires d'inclusion systèmes ( /usr/include , au moins )*/
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#include "globales.h"
#include "config.h"
#include "SDL.h"
 
intp nb_parties=0;
intp nb_gagnes=0;        /* ces variables viennent de global.h >> extern */
intp nb_perdues=0;
intp score_total=0;
 
void exit_with_error(char *text, int status)        /*faire un rapport d'erreur */
{
	fprintf(stderr, "%s\n", text);  /*on va afficher la chaine de caractères texte*/
	exit(status);
}
 
void *smalloc(size_t taille)       /*"void" signifiait "vide" et qu'on utilisait ce type pour indiquer que la fonction ne retournait aucune valeur.
Alors ici, on aurait une fonction qui retourne un "pointeur sur vide"  renvoie un pointeur indiquant l'adresse que l'OS a réservé pour votre variable.Comme malloc ne sait pas quel type elle doit retourner, elle renvoie le type void*. Ce sera un pointeur sur n'importe quel type. On peut dire que c'est un pointeur universel.*/
{
	void * nouveau = (void *) malloc (taille);        /*on se, fou du type de nouveau*/
	if (nouveau==NULL)             /* lalloc a echouée*/
    {
		fprintf(stderr,"Erreur lors de l'allocation de %d octets. Mémoire insuffisante ?", taille);
		exit(EXIT_MEM_ERROR); /* renvoie pb de MEM*/
	}
	return(nouveau);
}
 
int main (void)
{
 
    initialisation_SDL();
	srand((int) time(NULL));  /* init de rand pour solution aléatoire */
	jeu();
	return 0;
 
}

globales.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
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
#ifndef GLOBAL_INCLUDED
#define GLOBAL_INCLUDED
 
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
 
#define MALLOC_CHECK_		2
/* détection des erreurs d'allocation et de libéraion */
 
#define EXIT_ARG_ERROR	1
#define EXIT_MEM_ERROR	2
 
#define LARG_MIN		1
#define LARG_MAX	    9
extern int larg;		/* largeure du jeu : nombre de boules dans une ligne du plateau*/
 
#define COUP_MAX        10     //JAI RAJOUETR
 
#define NB_MIN			1
#define NB_MAX			9
extern int nb;			/* nombre de couleurs de boules*/
 
#define OUI 1
#define NON 0
 
#define PERDU 1
#define GAGNE 2
 
typedef long int intc; /*une partie pour nb=7 et larg=7 comportes 823 542 >>>coups (77) dans l'ensemble de départ. Nous avons donc défini un type intc, qui est utilisé pour tous les nombres en rapport avec la quantité ou la position des coups dans l'ensemble.*/
typedef long int intp; /* pour >>>parties*/
typedef char* coup;
 
typedef struct {      /*Lors de la partie, nous allons avoir besoin de vérifier un grand nombre de coups et donc de stocker les vérifications pour pouvoir indiquer au joueur les pions qu’il a correctement placé et ce qui ne le sont pas. C’est pour cette raison que nous avons choisi de définir une structure VERIF nous permettant de stocker les coups bien placés et les coups mal placés */
	int correct;
	int mal_place;
	int mauvais;
 
       } VERIF;
 
intp nb_partie;
int coup_max;
int use_menu;
int use_fullscreen;
int saisie_coup;
int score;
 
coup solution; /*  chaines de caractères*/
 
extern intp score_total;
extern intp nb_parties;
extern intp nb_gagnes;
extern intp nb_perdues;
 
extern void *smalloc(size_t taille);
 
#define EST_UN_PION(x)	(((x)>=0) && ((x)<nb))  /* le joueur ne peut entrer que des coups valides >>restriction, nous utilisons une macro-commande qui nous permet de savoir si une valeur est un pion ou non.
*/
#define SAUVEGARDE "matstemind.conf"   /*mastermind.config !!!*/
 
#endif

SDL.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
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
/* Inclusion des différentes bibliothèques necessaires au mode SDL*/
#include <time.h>
#include <SDL/SDL.h>
 
#include "config.h"
#include "globales.h"
//#include "SFont.h"   // pour la police
 
 
 
/* Définition des diverses images utilisées dans le mode SDL */
#define FOND "images/matstemind.bmp"
#define INTRO "images/intro2.bmp"
#define PLATEAU "images/jeux.bmp"
#define CORRECT "images/good.bmp"
#define MAL_PLACE "images/not_bad.bmp"
#define FOND_OPTION "images/fond_option.bmp"
 
#define EVAL "images/evaluer.bmp"
#define START "images/start2.bmp"
#define OPTION "images/options2.bmp"
#define QUIT "images/quit2.bmp"
#define AIDE "images/aide.bmp"
 
#define START_ON "images/start_on.bmp"
#define OPTION_ON "images/options_on.bmp"
#define QUIT_ON "images/quit_on.bmp"
#define AIDE_ON "images/aide2.bmp"
#define EVAL_ON "images/evaluer_on.bmp"
 
#define SPR_LARGEUR "images/largeur.bmp"
#define SPR_COULEUR "images/nb_couleur.bmp"
#define SPR_CHIFFRES "images/chiffres.bmp"
#define SPR_IA "images/ia.bmp"
#define SPR_OUI "images/oui.bmp"
#define SPR_NON "images/non.bmp"
#define ANNULER "images/annuler.bmp"
#define SAUVER "images/sauver.bmp"
 
#define ANNULER_ON "images/annuler_on.bmp"
#define SAUVER_ON "images/sauver_on.bmp"
 
/* Définition du nombre maximal de couleur (+1 pour la couleur vide) */
#define MAX_COULEUR 11
 
/* Définition du nombre d'options maximum à sauver */
#define OPTIONS_A_SAUVER 10
 
/* Définition de la résolution de l'écran */
#define WIDTH 800
#define HEIGHT 600
 
/* Définition de la résolution des images des boulles */
#define X_BOULLE 50
#define Y_BOULLE 50
 
/* Définition du nombre maximum de coup possibles*/
#define COUP_MAX 10
/* Définition de l'origine de l'écran*/
#define ORIGINE 0
/* Définition de la case vide */
#define VIDE 10
 
SDL_Surface *screen;   // Ecran
SDL_Surface *Font;// Font : police utilisée dans tout le programme
int flag_aide=0;  // Flag définissant si la fenêtre d'aide est active
 
 
float coordonnees_x[LARG_MAX];    //tableau des coordonnées du Mastermind
float coordonnees_y[COUP_MAX+1];
 
 
/*tableau des noms des fichiers image des différentes boulles*/
char * boulles[MAX_COULEUR]={"images/boulle_rouge.bmp","images/boulle_blanche.bmp","images/boulle_bleu.bmp",\
					"images/boulle_bleuclair.bmp","images/boulle_grise.bmp","images/boulle_jaune.bmp",\
					"images/boulle_kaki.bmp","images/boulle_noire.bmp","images/boulle_orange.bmp",\
					"images/boulle_verte.bmp", "images/boulle_vide.bmp"};
 
/*tableau des images des boulles elle-mêmes */
SDL_Surface *images_boulles[MAX_COULEUR];
 
/*Variable permettant de controler un timer d'affichage*/
int flag_timer=0;
 
 
//Fonction de tirage de la combinaison secrète
coup coup_alleatoire()
{
 
    coup soluce;
    int i;
 
    for(i=0; i=MAX_COULEUR; i++)
    {
 
        soluce[i]= (rand()%26+1);
    }
    return soluce;
}
/*       ?????????????????????????????????????????    2 fct qui viennet du code TXT
//Fonction de lecture de la proposition du joueur avec controle de validité et conversion char[]>>int []
int entree(int prop[NPOS])
{
    char ch[NPOS+3]; // chaine ou sera lue la proposition du joueur  on fait de la place en + : 3 cases en plus dans ce tableau de char (\0, nbr caract reel, nbr max de caract a entrer)
    int i;
 
    //lecture proposition du joueur dans chaine ch
    ch[0]=NPOS+1;  // +1 car on compte en plus le \0  Préparation longueur max chaine lue
    cgets(ch);     //la fonction lit les 6 caractères rentrés: pas plus>
 
    //controles
    if(strlen(&ch[2]) != NPOS)   //fonction type: strlen(char* );  or char ch[NPOS] = char* ch : tableau de char
    {                     //pas compris &ch[2]   jaurai mis 1
        return -1;
    }                      //on a pas autant de chiffres: de caract que de cases dans le jeu > entree incorecte
    for(i=2; i<NPOS+2;i++)
    {
        if(ch[i] < '1' || ch[i]> '1'+NCHIF-1)
        {           //val:49
            return -1;  //reponse invalide
        }
    }
 
    //extraction des chiffres entres
    for(i=0; i<NPOS;i++)
    {
        prop[i]=ch[2+i] -'0';
    }
    return 0;   //reponse valide
}
 
//Fonction d'analyse de la proposition du joueur: indique les chiffres exacts bien placés ou non
void analyse(int prop[], int tir[],int bpos[], int bchif[])
{
    int tir_bis[NPOS];
    int i,j;
 
    for(i=0;i<NPOS;i++)
    {
        tir_bis[i]=tir[i];  //copie de la combinaison secrète
    }
 
    //comptage bonnes positions
    *bpos=0;
    for(i=0;i<NPOS;i++)
    {
        if(prop[i]==tir_bis[i])
        {
            (*bpos)++;
            tir_bis[i]=prop[i]=0;  //alors on "supprime" cette valeur pour ne pas la recompter
        }
    }       // a cet instant on connait tous les chiffres exacts bien placés
 
    //Comptage bons chiffres mal placés
    *bchif=0;
    for(i=0;i<NPOS;i++)
    {
        for(j=0;j<NPOS;j++)  //2eme boucle permet de se déplacer dans la combinaison secrète tiree via j , à i fixé sur la proposition du joueur
        {
            if((prop[i] != 0 )&& (prop[i]==tir_bis[j]))
            {
                (*bchif)++;
                prop[i]=tir_bis[j]=0; //alors on "supprime" cette valeur pour ne pas la recompter
            }
        }
    }
}
*/
void affiche_aide(void)   // affichage du menu aide
{
	SDL_Event event;
 
	/* On définie le titre de la fenêtre SDL*/
	SDL_WM_SetCaption("MatSteMind - Aide", NULL);
 
    efface_screen();  /*efface le menu principal*/
	PutString(screen,350,40,"A I D E\0");
	PutString(screen,20,160,"Pour jouer, il vous suffit de choisir votre\0");
	PutString(screen,20,200,"  combinaison en cliquant sur les boulles\0");
	PutString(screen,20,240,"  pour faire defiler les couleurs.\0");
	PutString(screen,20,320,"Une fois la combinaison choisie, cliquez\0");
	PutString(screen,20,360,"  sur evaluer ;)\0");
	PutString(screen,20,440,"Bonne partie...\0");
	PutString(screen,600,480,"Mat et Ste\0");
	PutString(screen,100,560,"Appuyez sur une touche pour continuer\0");
	SDL_Flip(screen);
	do{
		SDL_WaitEvent(&event);
		SDL_Delay(20);
	}while (event.type!=SDL_KEYDOWN && event.type!=SDL_MOUSEBUTTONDOWN);
	efface_screen();
	SDL_WM_SetCaption("MatSteMind", NULL);	/* on revient au menu principal en chargeant le titre mais aussi limage*/
}
 
 
/* Fonction d'affichage des pions bien placés et mal placés */
void affiche_result_graph(VERIF verification, int niveau)  //niveau ou on est sur la ligne
{
	int i,j;
	SDL_Surface *temp;
 
	/*On affiche l'image CORRECT pour chaque pions bien placé*/
	for (i = 0 ; i < verification.correct ; i++)
	{
		temp = charge_image(CORRECT);
		affiche_image(temp, 0, 0, temp->w, temp->h, i*25 + 450, coordonnees_y[niveau], temp->w, temp->h);  /* les meme L et H pour superposition des fonds */
		SDL_FreeSurface(temp);
 
	}
	/*On affiche l'image MAL_PLACE pour chaque pions mal placés*/
	for (j = 0 ; j < verification.mal_place ; j++)
	{
		temp = charge_image(MAL_PLACE);
		affiche_image(temp, 0, 0, temp->w, temp->h, i*25 + 450, coordonnees_y[niveau], temp->w, temp->h);
		i++;
		SDL_FreeSurface(temp);
	}
}
 
/* Initialisation des coordonnées du plateau de jeu */
void init_coordonnees_MasterMind(void)
{
	int i;
	for (i=0 ; i<COUP_MAX; i++)
	{
               	coordonnees_y[i] = Y_BOULLE*i + ORIGINE;
    }
	for (i=0 ; i<LARG_MAX;i++)
    {
		coordonnees_x[i] = X_BOULLE*i + ORIGINE;
    }
}
 
 
/*Fonction d'affichage du plateau vide*/
void affiche_plateau_vide(void)
{
	int i, j;
	SDL_Surface *action;
 
	/*On affiche larg * COUP_MAX cases vides*/
		for (i=0 ; i<larg ; i++)
		{
                   for (j=0 ; j<COUP_MAX; j++)
                   {
			          affiche_image(images_boulles[VIDE], 0, 0, images_boulles[VIDE]->w, images_boulles[VIDE]->h, coordonnees_x[i], coordonnees_y[j], images_boulles[VIDE]->w, images_boulles[VIDE]->h);
                   }
		}
	/*On affiche l'image EVAL qui correspond au boutton sur lequel on appuiera pour lancer l'évaluation*/
	action = charge_image(EVAL);
	affiche_image(action, 0, 0, action->w, action->h, 150, 550, action->w, action->h);
	SDL_FreeSurface(action);
}
 
 
/*Fonction permettant de tester si le click de la souris a été effectué sur une boulle */
int clic_bon_endroit_sur_boulle(int x, int y, int niveau, int couleur)      /* x et y sont les coordonnées ou on a cliqué*/
{
	int ret=-1 ; //Variable de retour
	int i;
	/* Si le click a été éffectué sur le niveau sur lequel on se situe (niveau=n° du coup actuel)   sinon on ne fait rien */
	if ( (y>=(coordonnees_y[niveau] )) && (y<=(coordonnees_y[niveau]+Y_BOULLE)) )  /* on considère la hauteur en pixel d'une image de boulle*/
    {
		/*On scane toute la largeur du plateau pour trouver sur quelle boulle on a clické*/
		for ( i=0 ; i<larg ; i++)
		{	/* Si on a clické sur la ième boulle, on positionne ret à i et on sort de la boucle for*/
			if ( (x>=coordonnees_x[i]) && (x<=coordonnees_x[i]+X_BOULLE) )
            {
				ret=i;
				break;    /* on arrete la boucle >> on en sort avec certaines valeurs de  i et j */
			}
        }
		/*Si on a clické sur une boulle, on affiche la boulle de couleur : couleur*/
		if (ret!=-1)
		{
                    	affiche_image(images_boulles[couleur], 0, 0, images_boulles[couleur]->w, images_boulles[couleur]->h, coordonnees_x[i],coordonnees_y[niveau], images_boulles[couleur]->w, images_boulles[couleur]->h);
        }            /* blittage */
	}                          /*tableau des images des boulles elle-mêmes */
                                                   // SDL_Surface *images_boulles[MAX_COULEUR];
 
    else
	{	/*sinon on positionne ret à -1 -> on a pas clické sur une boulle*/
			 ret=-1;
    }
	return(ret);
}
 
 
/*Fonction permettant de charger une image de facon améliorée apar rapport a img_load*/
SDL_Surface * charge_image(const char *fichier)
{
	SDL_Surface * temp;
	SDL_Surface * Surf;
 
	Surf=SDL_LoadBMP(fichier); /*on charge nimporte quelle image */
 
	if (Surf==NULL)
    {
		fprintf(stderr, "Impossible de charger l'image %s\n", fichier);
		exit (1);
	}
        /*Cette fonction prend en entrée une surface quelconque, et renvoie une (autre) surface ayant le même format que la surface vidéo.
 
         L'interêt réside dans la vitesse de l'execution de la fonction SDL_BlitSurface. En effet, pour qu'une surface puisse être collée sur une autre, il faut que toutes deux aient le même format de pixel.
            S i lors de l'appel à SDL_BlitSurface les deux surfaces n'ont pas le même format, SDL_BlitSurface effectue la conversion pour vous (en appelant SDL_ConvertSurface). Mais cela prend (énormement) de temps. Or si l'on doit coller une surface à l'écran beaucoup de fois, mieux vaut changer son format dès le départ.
 
           */
	temp=SDL_DisplayFormat(Surf);
	if (temp==NULL)
        {
		fprintf(stderr, "Impossible de charger l'image %s\n", fichier);
		exit (1);
	}
	SDL_FreeSurface(Surf);
	SDL_SetColorKey(temp, SDL_SRCCOLORKEY,(Uint16) SDL_MapRGB(temp->format, 255, 0, 255) );  /*permet la transparence d'une image avec la couleur de fond de liomage a rendre transparente*/
	return (temp);
}
 
 
/*Fonction d'affichage d'une image
				- image : image a afficher
				- x_src : coordonnée x sur image a afficher
				- y_src : coordonnée y sur image a afficher
				- width_src : largeur de l'image source
				- height_src : hauteur de l'image source
 
				- x_dest : coordonnée x sur l'écran a afficher
				- y_dest : coordonnée y sur l'écran a afficher
				- width_dest : largeur de l'image source sur l'écran
				- height_dest : hauteur de l'image source sur l'écran*/
void affiche_image(SDL_Surface *image, int x_src, int y_src, int width_src, int height_src, int x_dest, int y_dest, int width_dest, int height_dest)
{
	SDL_Rect src, dest;  /* src : ptite image a coller*/
 
	src.x = x_src;
	src.y = y_src;
	src.w = width_src;
	src.h = height_src;
	dest.x = x_dest;
	dest.y = y_dest;
	dest.w = width_dest;
	dest.h = height_dest;
 
	SDL_BlitSurface(image, &src, screen, &dest);
	SDL_Flip(screen);
}
 
 
/*Fonction permettant d'effacer l'écran*/
void efface_screen(void)
{
	Uint32 black;   /*type unsigned 32 bits  besoin de stocker des grands nombres (jusqu'a 4 milliards) et que tu n'as pas besoin de nombre négatifs*/
	SDL_Rect zone, zone2;  /*typedef struct{
                                                   Sint16 x, y;
                                                   Uint16 w, h;
                                                } SDL_Rect;*/
 
	zone.w=zone2.w=(Uint16) screen->w;   /*  pour conversion  de type a la taille de ecran */
	zone.x=zone2.x=0;
 
	zone.h=zone2.h=(Uint16) 16;
 
	black = SDL_MapRGB (screen->format, 0, 0, 0);  /* fct renvoie un Uint correpsondant a la couleur */
 
	for (zone.y=0,zone2.y=((Sint16)screen->h)-zone.y-16;    (zone.y-16) < zone2.y;    zone.y+=16,zone2.y-=16 )
    {
		SDL_FillRect(screen, &zone, black);
		SDL_FillRect(screen, &zone2, black);
		SDL_Flip(screen);
		SDL_Delay(30);
	}
}
 
/*Fonction d'initialisation de SDL*/
int initialisation_SDL(void)
{
 
	/* Initialise le systeme video SDL */
	if (SDL_Init( SDL_INIT_EVERYTHING ) == -1)
    {
              // Unrecoverable error, exit here.
               printf("SDL_Init failed: %s\n", SDL_GetError());
    }
	/* Fonction permettant de quitter proprement SDL lorsqu'on quitte le programme */
	atexit(SDL_Quit);  /*atexit (fonction), dit au système d'executer SDL_Quit quand le programme se fermera*/
 
	/*définir le mode video WIDTHxHEIGHT (16-bit) en double buffer. */
	screen = SDL_SetVideoMode(WIDTH, HEIGHT, 16, SDL_DOUBLEBUF | use_fullscreen);
	if (screen == NULL)
    {
		printf("Impossible  to set video mode: %s\n", SDL_GetError());
		exit(1);
	}
	/* On définie le titre de la fenêtre SDL*/
	SDL_WM_SetCaption("MatSterMind", NULL);
 
        //printf("titre OK\n");
 
	/*Définition de la couleur de transparence*/
	SDL_SetColorKey(screen, SDL_SRCCOLORKEY,(Uint16) SDL_MapRGB(screen->format, 255, 0, 255) );  /*Elle prend en paramètres une surface, un flags et une couleur, et affecte la couleur comme couleur de transparence dans la surface.
                         C'est à dire qu'à chaque fois qu'on blittera cette surface sur une autre, tous les pixels de cette couleur qu'elle contient seront ignorés.
 
                              Pour le flag,vous avez deux possibilités : SDL_SRCCOLORKEY qui fixe la clé de couleur sur la surface ou 0 qui l'annule.*/
 
        /*Activation du curseur*/
	SDL_ShowCursor(SDL_ENABLE);
 
	/*Initialisation d'une police que l'on utilisera tout au long du mode SDL*/
	Font=SDL_LoadBMP("images/24P_Arial_NeonYellow.bmp");
	InitFont(Font);   // init de la police
 
	return 0;
}
 
 
/*Fonction de gestion du menu (1->Start ; 2->Option )*/
 
int menu_sdl(void)     /* car on retourn un entier */
{
	SDL_Surface *temp;
	SDL_Surface *boulle;
	SDL_Surface *start;
	SDL_Surface *start_on;
	SDL_Surface *aide;
	SDL_Surface *aide_on;
	SDL_Surface *option;
	SDL_Surface *option_on;
	SDL_Surface *quit;
	SDL_Surface *quit_on;
	SDL_Event event;
 
	/* Flags permettant de contrôler l'affichage des sprites(permet d'éviter l'affichage multiple de la même image)*/
 
	int flag_select_start=0;
	int flag_select_option=0;
	int flag_select_quit=0;
	int flag_select_aide=0;
 
	efface_screen();
 
         //boulle=charge_image(GROSSE_BOULLE);
         //affiche_image(boulle, 0, 0, boulle->w, boulle->h, 0, 0, boulle->w, boulle->h);       /*Inutile */
         //SDL_FreeSurface(boulle);
 
 
	temp=charge_image(FOND);
        //PutString(screen,220,560,"Appuyez sur <h> pour obtenir l'aide\0");
	affiche_image(temp, 0, 0, temp->w, temp->h, 100, 180, temp->w, temp->h);
 
 
	start=charge_image(START);
	affiche_image(start, 0, 0, start->w, start->h, 300, 310, start->w, start->h);
	option=charge_image(OPTION);
	affiche_image(option, 0, 0, option->w, option->h, 269, 366, option->w, option->h);
	quit=charge_image(QUIT);
	affiche_image(quit, 0, 0, quit->w, quit->h, 300, 425, quit->w, quit->h);
	aide=charge_image(AIDE);
	affiche_image(aide, 0, 0, aide->w, aide->h, 255, 500, aide->w, aide->h);
 
 
	/*Chargement des image des menus  mais on ne blitte pas*/
	start_on=charge_image(START_ON);
	option_on=charge_image(OPTION_ON);
	quit_on=charge_image(QUIT_ON);
	aide_on=charge_image(AIDE_ON);
 
 
	do {
 
	    /* Capture des événements :
					la Souris a bougé sur un élément du menu -> On anime le menu
					On a clické sur un élément du menu -> on retourne la valeur correspondant au menu clické
					On a appuyé sur ESC ou q-> on quitte le programme
					On a fermé la fenêtre ->idem       */
 
		while( SDL_PollEvent(&event) > 0 )
        {
			switch(event.type)
            {
				/*On quitte le programme */
				case SDL_KEYDOWN :
					if (!( (event.key.keysym.sym==SDLK_ESCAPE) || (event.key.keysym.sym==SDLK_q)))
                    {
                 	    if ((event.key.keysym.sym)==SDLK_h)
                        {
							affiche_aide();
							affiche_image(temp, 0, 0, temp->w, temp->h, 100, 180, temp->w, temp->h);
							affiche_image(start, 0, 0, start->w, start->h, 300, 310, start->w, start->h);
							affiche_image(option, 0, 0, option->w, option->h, 269, 366, option->w, option->h);
							affiche_image(quit, 0, 0, quit->w, quit->h, 300, 425, quit->w, quit->h);
							affiche_image(aide, 0, 0, aide->w, aide->h, 255, 500, aide->w, aide->h);
						}
						break;
					}
                case SDL_QUIT :        /* croix */
					SDL_FreeSurface(temp);
					SDL_FreeSurface(start);
					SDL_FreeSurface(option);
					SDL_FreeSurface(quit);
					SDL_FreeSurface(aide);
					SDL_FreeSurface(start_on);
					SDL_FreeSurface(option_on);
					SDL_FreeSurface(quit_on);
					SDL_FreeSurface(aide_on);
					SDL_FreeSurface(screen);
					printf("Fin du programme.\n") ;
					exit(0); /* quitte le programme
 
				/*On bouge la souris */
			    case SDL_MOUSEMOTION :
					//On bouge la souris sur Start
					if ( (event.motion.x>=300)&&(event.motion.x<=426)&&(event.motion.y>=310) && (event.motion.y<=350) )
                    {
						if (flag_select_start==0)
                        {
							flag_select_start = 1; //On est sur Start
							/*Affichage de l'image correspondant à Start >> start on en rouge*/
							affiche_image(start_on, 0, 0, start_on->w, start_on->h, 304, 309, start_on->w, start_on->h);
						}
					}
                    else
                    {
						if (flag_select_start==1)
                        {
							flag_select_start=0; // On quit Start
							/*Affichage de l'image du menu sur la zone du sprite Start  -> réinitialise le sprite*/
							affiche_image(start, 0, 0, start->w, start->h, 300, 310, start->w, start->h);
						}
					}
 
					// On bouge la souris sur Option
					if ( (event.motion.x>=269)&&(event.motion.x<=459)&&(event.motion.y>=370)&&(event.motion.y<=405) )
                    {
						if (flag_select_option==0)
                        {
							flag_select_option = 1; //On est sur Option
							/*Affichage de l'image correspondant à Option*/
							affiche_image(option_on, 0, 0, option_on->w, option_on->h, 280, 366, option_on->w, option_on->h);
						}
					}
                    else
                    {
						if (flag_select_option==1)
                        {
							flag_select_option=0; // On quit Option
							/*Affichage de l'image du menu sur la zone du sprite Option  -> réinitialise le sprite*/
							affiche_image(option, 0, 0, option->w, option->h, 269, 366, option->w, option->h);
						}
					}
 
					// On bouge la souris sur Quit
					if ( (event.motion.x>=300)&&(event.motion.x<=410)&&(event.motion.y>=430)&&(event.motion.y<=463) )
                    {
						if (flag_select_quit==0)
                        {
							flag_select_quit = 1;// On est sur Quit
							/*Affichage de l'image correspondant à Quit*/
							affiche_image(quit_on, 0, 0, quit_on->w, quit_on->h, 307, 428, quit_on->w, quit_on->h);
						}
					}
                    else
                    {
						if (flag_select_quit==1)
                        {
							flag_select_quit=0; // On quitte Quit
							/*Affichage de l'image du menu sur la zone du sprite Quit  -> réinitialise le sprite*/
							affiche_image(quit, 0, 0, quit->w, quit->h, 300, 425, quit->w, quit->h);
						}
					}
 
					// On bouge la souris sur Aide
					if ( (event.motion.x>=290)&&(event.motion.x<=410)&&(event.motion.y>=500)&&(event.motion.y<=550) )
                    {
						if (flag_select_aide==0)
                        {
							flag_select_aide = 1;// On est sur Aide
							/*Affichage de l'image correspondant à Aide*/
							affiche_image(aide_on, 0, 0, aide_on->w, aide_on->h, 262, 500, aide_on->w, aide_on->h);
						}
					}
                    else
                    {
						if (flag_select_aide==1)
                        {
							flag_select_aide=0; // On quitte Aide
							/*Affichage de l'image du menu sur la zone du sprite Aide  -> réinitialise le sprite*/
							affiche_image(aide, 0, 0, aide->w, aide->h, 255, 500, aide->w, aide->h);
						}
					}
 
 
					break;
 
					case SDL_MOUSEBUTTONDOWN:
					//On a appuyer sur aide
					if (flag_select_aide==1)        /* on est sur le sprite d'aide >> il passe en rouge et si on clique dessus en plus */
                    {
						affiche_aide();
						affiche_image(temp, 0, 0, temp->w, temp->h, 100, 180, temp->w, temp->h);
						affiche_image(start, 0, 0, start->w, start->h, 300, 310, start->w, start->h);
						affiche_image(option, 0, 0, option->w, option->h, 269, 366, option->w, option->h);
						affiche_image(quit, 0, 0, quit->w, quit->h, 300, 425, quit->w, quit->h);
						affiche_image(aide, 0, 0, aide->w, aide->h, 255, 500, aide->w, aide->h);
 
					}
 
					//On a appuyer sur start
					if (flag_select_start)
                    {
						efface_screen();
						SDL_Flip(screen);
						SDL_FreeSurface(temp);
						SDL_FreeSurface(start);
						SDL_FreeSurface(option);
						SDL_FreeSurface(quit);
						SDL_FreeSurface(aide);
						SDL_FreeSurface(aide_on);
						SDL_FreeSurface(start_on);
						SDL_FreeSurface(option_on);
						SDL_FreeSurface(quit_on);
 
 
						// On retourne 1
						return (1);
					}
					//On a appuyer sur option
					if ( flag_select_option)
                    {
						efface_screen();
						SDL_Flip(screen);
						SDL_FreeSurface(temp);
						SDL_FreeSurface(start);
						SDL_FreeSurface(option);
						SDL_FreeSurface(quit);
						SDL_FreeSurface(aide);
						SDL_FreeSurface(aide_on);
						SDL_FreeSurface(start_on);
						SDL_FreeSurface(option_on);
						SDL_FreeSurface(quit_on);
 
 
						// On retourne 2
						return 2;   /* quitte la fonctio */
					}
					break;
				}
			}
		SDL_Delay(20);		// Temporisation pour laisser le processeur souffler
	} while (1);
	return 0;
}
 
 
 
/* Initialisation des image des pions*/
void init_image_pions(void)
{
   int i;
   for (i=0;i<MAX_COULEUR;i++)
   {
		images_boulles[i]=charge_image(boulles[i]);
   }
}
 
 
 
/*Libération des images des pions*/
void free_image_pions(void)
{
	int i;
	for (i=0;i<MAX_COULEUR;i++)
	{
			SDL_FreeSurface(images_boulles[i]);
	}
 
}
 
 
/*Affichage d'un coup*/
void affiche_coup( coup coup_a_afficher, int niveau )        /* char * coup   ou char ....[] >> global.h*/
{
	int i;
	int couleur;
	for (i=0 ; i<larg ; i++)
	{
		couleur=(int)coup_a_afficher[i]; /* converison de type */
		affiche_image(images_boulles[couleur], 0, 0, images_boulles[couleur]->w, images_boulles[couleur]->h,coordonnees_x[i], coordonnees_y[niveau], images_boulles[couleur]->w, images_boulles[couleur]->h);
	}
}
 
 
 
/*Fonction de jeu  quand on a déja cliquer sur start*/
int jeu(void)
{
    SDL_Event event;
    VERIF verification;
    char coup_joueur[larg];
    int nb_coup=0, nb_click=1, n_pion=0;
    int i;
 
	int flag_evaluation=0;
	SDL_Surface *eval;
	SDL_Surface *eval_on;
 
	eval=charge_image(EVAL);
	eval_on=charge_image(EVAL_ON);
 
	solution = coup_alleatoire();    /*global .h coup solution;  tableau de chaines de caractères contenant le code           coup_alleatoire cf ma fonction ???*/
	init_coordonnees_MasterMind();   /* Initialisation des coordonnées du plateau de jeu */
	init_image_pions();
 
	affiche_plateau_vide();  /*On affiche larg * COUP_MAX cases vides : plateau vide +EVAL */
 
	for (i=0 ; i<=larg ; i++)
    {
		 coup_joueur[i]=0;
    }
	affiche_coup(coup_joueur, nb_coup);
 
	SDL_EventState(SDL_KEYUP, SDL_ENABLE);       /*ce type d'évènement sera traité normalement */
	SDL_EventState(SDL_KEYDOWN, SDL_ENABLE);
 
	while (1)
	{
		while( SDL_PollEvent(&event) > 0 )
		{
			switch(event.type)
            {
				case SDL_KEYDOWN:
					if (!( (event.key.keysym.sym==SDLK_ESCAPE) || (event.key.keysym.sym==SDLK_q)))
					{
					     break;
                    }
					SDL_FreeSurface(eval);
					SDL_FreeSurface(eval_on);
					efface_screen();
					SDL_Flip(screen);       /* on revient au menu principal seulement*/
					return(1);
 
				case SDL_QUIT :
					SDL_FreeSurface(screen);   /*car on quitte tout la */
					SDL_FreeSurface(eval);
					SDL_FreeSurface(eval_on);
					free(solution);
					free_image_pions();
					printf("Fin du programme.\n") ;
					exit(0);
				case SDL_MOUSEMOTION:
                    if ((event.motion.y>=550)&&(event.motion.y<=600))
                    {
						if (flag_evaluation==0)
                        {
							flag_evaluation=1;   /* eval>>eval_on en rouge*/
							affiche_image(eval_on, 0, 0, eval_on->w, eval_on->h, 150, 550, eval_on->w, eval_on->h);
						}
					}
                    else
                    {
						if (flag_evaluation==1)
                        {
							flag_evaluation=0;
							affiche_image(eval, 0, 0, eval->w, eval->h, 150, 550, eval->w, eval->h);
 
						}
					}
					break;
                 case SDL_MOUSEBUTTONDOWN:   /* c'est qu'on clique */
					if (!flag_evaluation)
                    {
						n_pion=clic_bon_endroit_sur_boulle(event.motion.x, event.motion.y, nb_coup, nb_click);/* permet de savoir si le clique a été fait sur une boule */
						if(n_pion!=-1)   /* on a bien cliquer sur une boule */
                        {
							coup_joueur[n_pion]=nb_click;   /* = ième boule  >> chaine de caractère[0] = 3 par ex */
							nb_click=(nb_click+1)%nb;
						}
					}
                    else    /* c'est qu'on a cliquer sur eval */
                    {
						if (nb_coup<COUP_MAX)
                        {
                              affiche_coup( coup_joueur, nb_coup+1);
                        }
						analyse_combi_saisie(solution, coup_joueur, &verification);  /* on regarde si la combinaison est bonne :normal car demande d'eval  cf ma fonction avec coup_joueur char []*/
						affiche_result_graph(verification, nb_coup);     /* affiche les pions rouges et blancs  bien ou mal placés car now on sait verification-> correct ...*/
						nb_coup++;
						if (verification.correct == larg) /* larg: nbr de boules */
                        {
							SDL_FreeSurface(eval);
							SDL_FreeSurface(eval_on);
							score=nb_coup;	 /* score: trouvez en 10 coups par ex*/
							efface_screen();
							SDL_Flip(screen);
							return 2;
						}
                        else
                        {
							if (nb_coup==COUP_MAX)  /* on ne peut plus essayer atteient le max*/
                            {
								SDL_FreeSurface(eval);
								SDL_FreeSurface(eval_on);
								return 1;
							}
						}
					}
 
			}
		}
		SDL_Delay(20);
	}
	return (1);
}
 
/*Fonction permettant de transformer un entier en chaine de caractère
(nous avons besoin de cette fonction pour afficher les différents nombres
avec la fonction Putstring qui permet l'affichage d'une chaine à l'écran)
le nombre ne doit pas dépasser 99 auquel cas, la chaine retournée sera
complètement différente du nombre voulu*/
 
 
char* SDL_itoa(int nb)
{
	char *nombre;	// nombre transformé à la fin de la fonction en chaine de caractère
	if (nb<10)
	{
		nombre=(char*)smalloc(2*sizeof(char));
		nombre[0]=(char) (nb+48);		// on ajoute 48 pour avoir le code ASCII de nb
		nombre[1]='\0';
		return(nombre);
	}
	else
	{
		nombre=(char*)smalloc(3*sizeof(char));
		nombre[1]=(char)((nb%10)+48);	// on ajoute 48 pour avoir le code ASCII de nb
		nombre[0]=(char)((nb/10)+48); 	// on ajoute 48 pour avoir le code ASCII de nb
		nombre[2]='\0';
		return(nombre);
	}
}
 
void gagne_sdl()
{
	SDL_Event event;
 
	efface_screen();
	SDL_Flip(screen);
 
	PutString(screen,280,40,"G A G N E\0");
	PutString(screen,150,200,"Vous avez reussi a trouver\0");
	PutString(screen, 60, 250, "la combinaison en\0");
	PutString(screen, 360, 250, SDL_itoa(score));         /* score : int >> conversion en char pour afficher*/
	PutString(screen, 400, 250, "coups\0");
 
	PutString(screen, 60, 350, "Total des parties :\0");
	PutString(screen, 600, 350, SDL_itoa(nb_parties));
	PutString(screen, 60, 400, "Parties gagnes :\0");
	PutString(screen, 600, 400, SDL_itoa(nb_gagnes));
	PutString(screen, 60, 450, "Parties perdues :\0");
	PutString(screen, 600, 450, SDL_itoa(nb_perdues));
 
	SDL_Flip(screen);
 
	free_image_pions();
	free(solution);
 
	SDL_EventState(SDL_KEYDOWN, SDL_ENABLE);
 
	while ( SDL_WaitEvent(&event)>=0 )
    {
		switch (event.type)
        {
			case SDL_KEYDOWN :
				if (!( (event.key.keysym.sym==SDLK_ESCAPE) || (event.key.keysym.sym==SDLK_q)))
					break;
			case SDL_MOUSEBUTTONDOWN :
				efface_screen();
				SDL_Flip(screen);
				return;
			case SDL_QUIT :
				SDL_FreeSurface(screen);
				SDL_FreeSurface(Font);
				printf("Fin du programme.\n") ;
				exit(0);
		}
	}
}
 
void perdu_sdl()
{
	SDL_Event event;    // Variable dans laquelle nous stockerons les divers évènements
	int couleur;	    // Couleur d'un pion lors de l'affichage de la solution
	int i;	            // Variable de bouclage
 
	efface_screen();
	SDL_Flip(screen);
 
	PutString(screen,280,40,"P E R D U  !\0");
	PutString(screen,110,220,"Le Resultat etait :\0");
 
    //Affichage du resultat
	for (i=0 ; i<larg ; i++)
    {
		couleur=(int)solution[i];
		affiche_image(images_boulles[couleur], 0, 0, images_boulles[couleur]->w, images_boulles[couleur]->h,i*80+20, 280, images_boulles[couleur]->w, images_boulles[couleur]->h);
	}
 
        //Affichage des statistiques
	PutString(screen, 60, 350, "Total des parties :\0");
	PutString(screen, 600, 350, SDL_itoa(nb_parties));
	PutString(screen, 60, 400, "Parties gagnes :\0");
	PutString(screen, 600, 400, SDL_itoa(nb_gagnes));
	PutString(screen, 60, 450, "Parties perdues :\0");     // un ptit % de réussite ???
	PutString(screen, 600, 450, SDL_itoa(nb_perdues));
	SDL_Flip(screen);
 
        //Libération des images des pions
	free_image_pions();
	free(solution);
 
 
        /* Mise en place des événements : dès qu'on appuie sur un boutton de la souris
		ou sur ESC ou q
			-> On revient au menu
	dès que l'on ferme la femêtre
			-> On quitte
             */
 
	while ( SDL_WaitEvent(&event)>=0 )
    {
		switch (event.type)
        {
			case SDL_KEYDOWN:
				if (!( (event.key.keysym.sym==SDLK_ESCAPE) || (event.key.keysym.sym==SDLK_q)))
					break;
			case SDL_MOUSEBUTTONDOWN :
				efface_screen();
				SDL_Flip(screen);
 
				return;
			case SDL_QUIT :
				SDL_FreeSurface(screen);
				SDL_FreeSurface(Font);
				printf("Fin du programme.\n") ;
				exit(0);
		}
	}
}
 
 
 
void option_sdl(void)
{
	int nb_arg=7;
    //int flag_ia=0;
	int flag_sauver=0;
	int flag_annuler=0;
	int i;
 
	char flag_largeur[2];
	char flag_couleur[2];
 
	char *options_a_sauver[OPTIONS_A_SAUVER]={"./matstermind\0","-c\0", NULL, "-l\0", NULL, "-m\0", "-a\0", NULL, "-i\0", "exh\0"};
 
	SDL_Surface *sauver_on;
	SDL_Surface *annuler_on;
	SDL_Surface *sauver;
	SDL_Surface *annuler;
	SDL_Surface *fond;
	SDL_Surface *spr_larg;
	SDL_Surface *spr_coul;
	//SDL_Surface *spr_ia;
	SDL_Surface *spr_chiffres;
	SDL_Surface *spr_oui;
	SDL_Surface *spr_non;
 
	SDL_Event event;
 
	Uint32 black;
	SDL_Rect zone;
 
	zone.w=(Uint16) 128;
	zone.h=(Uint16) 48;
 
	black = SDL_MapRGB (screen->format, 0, 0, 0);  /* on fou tout en noir */
 
	options_a_sauver[7]="sdl\0";
 
	flag_largeur[0]='4';
	flag_largeur[1]='\0';
	flag_couleur[0]='6';
	flag_couleur[1]='\0';
 
	fond=charge_image(FOND_OPTION);
	annuler_on=charge_image(ANNULER_ON);
	sauver_on=charge_image(SAUVER_ON);
	annuler=charge_image(ANNULER);
	sauver=charge_image(SAUVER);
	spr_larg=charge_image(SPR_LARGEUR);
	spr_coul=charge_image(SPR_COULEUR);
	//>>>spr_ia=charge_image(SPR_IA);
	spr_chiffres=charge_image(SPR_CHIFFRES);
	//>>>>spr_oui=charge_image(SPR_OUI);
	//>>>>>spr_non=charge_image(SPR_NON);
 
 
	affiche_image(fond, 0, 0, fond->w, fond->h, 250, 20, fond->w, fond->h);
	affiche_image(spr_coul, 0, 0, spr_coul->w, spr_coul->h, 0, 160, spr_coul->w, spr_coul->h);
	affiche_image(spr_chiffres, 0, 0, spr_chiffres->w, spr_chiffres->h, 0, 210, spr_chiffres->w, spr_chiffres->h);
	affiche_image(spr_larg, 0, 0, spr_larg->w, spr_larg->h, 0, 260, spr_larg->w, spr_larg->h);
	affiche_image(spr_chiffres, 0, 0, spr_chiffres->w, spr_chiffres->h, 0, 310, spr_chiffres->w, spr_chiffres->h);
	//>>>>affiche_image(spr_ia, 0, 0, spr_ia->w, spr_ia->h, 0, 360, spr_ia->w, spr_ia->h);
	affiche_image(spr_oui, 0, 0, spr_oui->w, spr_oui->h, 100, 420, spr_oui->w, spr_oui->h);
	affiche_image(spr_non, 0, 0, spr_non->w, spr_non->h, 250, 420, spr_non->w, spr_non->h);
	affiche_image(sauver, 0, 0, sauver->w, sauver->h, 535, 368, sauver->w, sauver->h);
	affiche_image(annuler, 0, 0, annuler->w, annuler->h, 511, 435, annuler->w, annuler->h);
 
	PutString(screen,390,165,flag_couleur);
	PutString(screen,187,265,flag_largeur);
	/*if (flag_ia)
		PutString(screen,90,365,"OUI\0");
	else
		PutString(screen,90,365,"NON\0");*/
 
	SDL_Flip(screen);
 
	while ( SDL_WaitEvent(&event)>=0 )
    {
		switch (event.type)
        {
			case SDL_MOUSEMOTION:
				if ( (event.motion.y>=372) &&(event.motion.y<=418) && (event.motion.x>=538))
                {
					if (!flag_sauver)
                    {
						flag_sauver=1;
						affiche_image(sauver_on, 0, 0, sauver_on->w, sauver_on->h, 535, 368, sauver_on->w, sauver_on->h);
					}
				}
                else
                {
					if (flag_sauver)
                    {
						flag_sauver=0;
                        affiche_image(fond, 537, 368, 190, 50, 537, 368, 0, 0);
						affiche_image(sauver, 0, 0, sauver->w, sauver->h, 535, 368, sauver->w, sauver->h);
					}
				}
 
				if ( (event.motion.y>=438) &&(event.motion.y<=468) && (event.motion.x>=528))
                {
					if (!flag_annuler)
                    {
						flag_annuler=1;
						affiche_image(annuler_on, 0, 0, annuler_on->w, annuler_on->h, 516, 435, annuler_on->w, annuler_on->h);
					}
				}
                else
                {
 
					if (flag_annuler)
                    {
							flag_annuler=0;
//							affiche_image(fond, 511, 435, 190, 50, 511, 435, 0, 0);
						        affiche_image(annuler, 0, 0, annuler->w, annuler->h, 511, 435, annuler->w, annuler->h);
					 }
                }
				break;
 
			case SDL_MOUSEBUTTONDOWN :
 
				// On a cliquer sur annuler
				if (flag_annuler)
                {
					SDL_FreeSurface(fond);
					SDL_FreeSurface(annuler_on);
					SDL_FreeSurface(sauver_on);
					SDL_FreeSurface(annuler);
					SDL_FreeSurface(sauver);
					SDL_FreeSurface(spr_larg);
					SDL_FreeSurface(spr_coul);
					SDL_FreeSurface(spr_chiffres);
					//SDL_FreeSurface(spr_ia);
					SDL_FreeSurface(spr_oui);
					SDL_FreeSurface(spr_non);
					efface_screen();
					return;
				}
 
 
				if (flag_sauver)
                {
		             options_a_sauver[2]=flag_couleur;
				     options_a_sauver[4]=flag_largeur;
 
					if (!sauv_conf (nb_arg+1, options_a_sauver))   /* donc 0 >> tout s'est bien passé */
					{
						init(nb_arg+1, options_a_sauver);
					}
                    else
                    {
                            printf("Sauvergade : Faillure\n" );
                    }
					SDL_FreeSurface(fond);
					SDL_FreeSurface(annuler_on);
					SDL_FreeSurface(sauver_on);
					SDL_FreeSurface(annuler);
					SDL_FreeSurface(sauver);
					SDL_FreeSurface(spr_larg);
					SDL_FreeSurface(spr_coul);
					SDL_FreeSurface(spr_chiffres);
					//SDL_FreeSurface(spr_ia);
					SDL_FreeSurface(spr_oui);
					SDL_FreeSurface(spr_non);
					efface_screen();
					return;
				}
 
 
				// On a cliquer sur un chiffre : nbr de couleur
 
				if ( (event.button.y>=215) &&(event.button.y<=240))
                {
					affiche_image(fond, 390, 165, 190, 50, 390, 165, 0, 0);
					if (event.button.x>=67)
						flag_couleur[0]='2';
					if  (event.button.x>=133)
						flag_couleur[0]='3';
					if  (event.button.x>=193)
						flag_couleur[0]='4';
					if  (event.button.x>=253)
						flag_couleur[0]='5';
					if  (event.button.x>=303)
						flag_couleur[0]='6';
					if  (event.button.x>=363)
						flag_couleur[0]='7';
					if  (event.button.x>=423)
						flag_couleur[0]='8';
					if  (event.button.x>=483)
						flag_couleur[0]='9';
					flag_couleur[1]='\0';
					zone.x=390;
					zone.y=165;
					SDL_FillRect(screen, &zone, black);
					PutString(screen,390,165,flag_couleur);
					SDL_Flip(screen);
				}
 
				// On a cliqué sur un chiffer largeur du plateau : nbr de boulles
				// Affichage de la largeur selectionnée
				if ( (event.button.y>=320) &&(event.button.y<=345))
                {
					affiche_image(fond, 187, 265, 190, 50, 187, 265, 0, 0);
					if (event.button.x>=67)
						flag_largeur[0]='2';
					if  (event.button.x>=133)
						flag_largeur[0]='3';
					if  (event.button.x>=193)
						flag_largeur[0]='4';
					if  (event.button.x>=253)
						flag_largeur[0]='5';
					if  (event.button.x>=303)
						flag_largeur[0]='6';
					if  (event.button.x>=363)
						flag_largeur[0]='7';
					if  (event.button.x>=423)
						flag_largeur[0]='8';
					if  (event.button.x>=483)
						flag_largeur[0]='9';
					flag_couleur[1]='\0';
					zone.x=187;
					zone.y=256;
					SDL_FillRect(screen, &zone, black);
					PutString(screen,187,265,flag_largeur);
					SDL_Flip(screen);
				}
 
 
			case SDL_KEYDOWN:
				if ( (event.key.keysym.sym==SDLK_ESCAPE) || (event.key.keysym.sym==SDLK_q))
                {
					SDL_FreeSurface(fond);
					SDL_FreeSurface(annuler_on);
					SDL_FreeSurface(sauver_on);
					SDL_FreeSurface(annuler);
					SDL_FreeSurface(sauver);
					SDL_FreeSurface(spr_larg);
					SDL_FreeSurface(spr_coul);
					SDL_FreeSurface(spr_chiffres);
					//SDL_FreeSurface(spr_ia);
					SDL_FreeSurface(spr_oui);
					SDL_FreeSurface(spr_non);
					efface_screen();
					return;
				}
				break;
 
			case SDL_QUIT :
				SDL_FreeSurface(Font);
				SDL_FreeSurface(fond);
				SDL_FreeSurface(annuler_on);
				SDL_FreeSurface(sauver_on);
				SDL_FreeSurface(annuler);
				SDL_FreeSurface(sauver);
				SDL_FreeSurface(spr_larg);
				SDL_FreeSurface(spr_coul);
				SDL_FreeSurface(spr_chiffres);
				//SDL_FreeSurface(spr_ia);
				SDL_FreeSurface(spr_oui);
				SDL_FreeSurface(spr_non);
				SDL_FreeSurface(screen);
				printf("Fin du programme.\n") ;
				exit(0);
		}
	}
}

SDL.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
#ifndef SDL_INCLUDED
#define SDL_INCLUDED
 
#include "globales.h"
 
extern int intro_sdl(void);
extern int partie_sdl(void);        /* protos des fonctions de global scope */
extern int menu_sdl(void);
extern void gagne_sdl(void);
extern void perdu_sdl(void);
extern void option_sdl(void);
extern int initialisation_SDL(void);
extern int jeu(void);
extern coup coup_alleatoire();
extern void affiche_aide(void);
extern void affiche_result_graph(VERIF , int );
extern void init_coordonnees_MasterMind(void);
extern void affiche_plateau_vide(void);
extern int clic_bon_endroit_sur_boulle(int , int , int , int );
//extern SDL_Surface* charge_image(const char *);
//extern void affiche_image(SDL_Surface *, int, int , int , int , int, int , int , int );
extern void efface_screen(void);
extern void init_image_pions(void);
extern void free_image_pions(void);
extern void affiche_coup( coup , int  );
extern char* SDL_itoa(int ) ;
extern
 
#endif

config.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
#include <unistd.h>          // LA !!!
#include <sys/types.h>
#include <sys/stat.h>      //LA!!!   S_IREAD | S_IWRITE | S_IEXEC déclarés dans stat.h pour être compatible UNIX et créer un fichier lecture/ écriture/ exécution autorisée, seul S_IWRITE utile sur PC), O_TRUNC vide le fichier s'il existait, O_EXCL renvoie une erreur si fichier existant (utilisé avec O_CREAT)
#include <fcntl.h>         //   LA!!!!
#include <stdio.h>
#include <time.h>
 
#include "globales.h"
#include "config.h"
 
 
//#include "disp_clr.h"
//#include "disp_gl.h"
#include "SDL.h"
//#include "ai.h"
//#include "ai_exh.h"
//#include "ai_lin.h"
 
#define O_COULEURS		"couleurs"
#define O_LARGEUR		"largeur"
#define O_AFFICHAGE		"affichage"
#define O_TXT			"texte"
#define O_CLR			"linux-texte"
#define O_SDL			"sdl"
#define O_GL			"gl"
 
 
#define O_IA			"ia"
 
#define O_EXH			"exh"
#define O_LIN			"lin"
 
#define O_PARTIE		"parties"
#define O_MENU		"menu"
#define O_FULLSCREEN	"full-screen"
#define O_DISABLE_COUP	"disable-coup"
 
#define strlcmp(x, y)	(  ((x)[0]=='-' ) && (( ((x)[1]=='-' ) && ( ! strcmp(&((x)[2]),y)) ) ||  (  ((x)[1]==(y)[0]) && ( (strlen(&(x)[1]))==1) ) ) )
 
 
int sauv_conf (int argc, char *argv[])
{
	int descripteur  /* ou Handle */, i;
	char sep=' ' ;        /* valeur correspondant à espace*/
	unlink(SAUVEGARDE);   /*variableSAUVEGARDE  extern de GLOBAL.h  que l'on SUPPR avec unlink */ //PK ???
 
	if (   ( descripteur =open(SAUVEGARDE, O_CREAT | O_WRONLY, 0600) ) == -1  )   /*O_CREAT crée le fichier s'il n'existe pas, au lieu de donner une erreur, sans effet s'il existe*/
    {      /* Si erreur */
		printf("Impossible d'ouvrir le fichier ou de creer le fichier de configuration\n");
		perror("  /* message d'erreur */");  /*perror, cette fonction renvoie un message par rapport à la dernière erreur (nom du fichier, numéro de ligne, type d'erreur suivant errno, etc...) alors que fprintf (stderr, ...); ici c'est ton message rien de plus.*/
		return 9;
	}
 
	for (i=0 ; i<argc ; i++)
    {                /* On peut ensuite, suivant le mode d'ouverture, soit lire soit écrire un bloc (l'opération est alors directement effectuée sur disque) :
                    int write(int handle, void *bloc, unsigned taille);*/
 
		write(descripteur, argv[i], strlen(argv[i]))  ;             /*On désigne le fichier destination par son handle (celui rendu par open),l'adresse du bloc à écrire et la taille*/
		                    /*strlen retourne le nombre de caractères dans une chaine de caractère char*, en les comptants jusqu'au zéro terminal, mais sans compter celui-ci dans le total. */
        write(descripteur, &sep, sizeof(char))  ;            /* & car il faut 1 adresse*/
 
     }
            /* Lorsque l'on ne se sert plus du fichier, il faut le fermer (obligatoire pour que le fichier soit utilisable par le système d'exploitation, entre autre mise à jour de sa taille :
                          int close(int handle)*/
 
           close(descripteur);
           return 0;          /* tout s'est bien passé : ouvert, ecriture, fermeture**/
 
}
 
 
/* Renvoie un tableau de caractère contenant la ligne de commande à executer: argv[] et modifie le paramètre nb_arg
qui contiendra le nombre d'argument de la ligne de commande */
 
char **charge_conf(int *nb_arg)
{
	char buffer[12][20];
	int descripteur, i=0, j=0, z, *argc;
	char **argument=NULL;
	char car;
 
//	printf("Entrée dans le chargement des options:\n");
	argc=(int *)smalloc(sizeof(int));
 
	if (  ( descripteur=open(SAUVEGARDE, O_RDONLY) ) == -1 )
    {
		fprintf(stderr,"Impossible de lire le fichier de configuration\n");      /* La on fait les 2 pour en cas d'erreur :fprintf et perror > num de ligne .. aurtres données*/
		perror("");
		return NULL;
	}
 
//	printf("Lecture des options\n");
	while (read(descripteur, &car, sizeof(char) )!=0)        /* int read(int handle, void *bloc, unsigned taille);*/
    {
        //lit dans le fichier désigné par son handle, et le met dans le bloc dont on donne l'adresse et la taille. La fonction retourne le nombre d'octets lus (<=taille, <si fin du fichier en cours de lecture, 0 si on était déjà sur la fin du fichier, -1 si erreur)
		printf("i:%d, car:%c\n", i, car);
		if (  (argument = (char **)realloc(argument, ( (i+1)*sizeof(char *)) )) == NULL   )  // Si la réallocation s'est bien passé, c'est à dire que realloc() n'a pas retourné NULL, alors, on affecte le résultat de la fonction à notre tableau
        {                                                               //realloc() peut faire office de fonction d'allocation dans un cas particulier: le cas où la fonction reçoit en adresse de base le pointeur NULL
             exit_with_error("Memoire\n", 1);            //Création d'un tableau de 3 entiers   : tabentier = realloc ( tabentier , 3 * sizeof(int) );
 
        }
		//printf("Arguments alloués\n");
		j=0;
		do{
		        printf("j:%d\n", j);
		        if (  (argument[i]=(char *)realloc(argument[i], (j+1)*sizeof(char)))==NULL  )
                {
                        exit_with_error("Allocation\n", 1);
                }
			    //argument[i][j]=car;
			   buffer[i][j]=car;
               read(descripteur, &car, sizeof(char) );
			   j++;
        } while(car != ' ' );
 
		argument[i][j]='\0';
		buffer[i][j]='\0';
		printf("Argument scanné : %s\n", argument[i]);
		printf("Argument scanné : %s\n", buffer[i]);
		i++;
	}
	*argc=i;
	argument=(char **)smalloc(i *sizeof(char*));
	printf("Taille de %d arguments : %d bits\n",i ,i*sizeof(char*));
	*nb_arg=i;
	for (j=0;j<*nb_arg;j++)
              {
		argument[j]=(char*)smalloc( (strlen(buffer[j])+1)*sizeof(char));
     	printf("Taille de buffer[%d] : %d\n",i, (strlen(buffer[j])+1) );
		for (z=0 ; z<(strlen(buffer[j])+1) ; z++) argument[j][z]=buffer[j][z];
		printf("Argument %d : %s\n", j, argument[j]);
	}
 
	close (descripteur);
	return(argument);
 
}

Erreurs:
-dans SDL.h:
l 20 : expected '=', ',' , ';','asm', or 'attribute' before '*' token
l21 : expected ')' beforer '*' token

[LittleWhite]

Bonjour,

Code :

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

//extern SDL_Surface* charge_image(const char *);

C'est parce qu'il faut la définition de ... SDL_Surface*
Donc , il faut inclure SDL.h (celui de la SDL, et non le votre) #include <SDL/SDL.h>

[Rodrig0]

Merci LittleWhite, je l'ai inclue et cette erreur a disparue seulement j'ai maintenant : dans SDL.h
error: conflicting types for 'itoa'

J'avais déja eu cette erreur pour d'autres fonctions de SDL.c à un moment et puis elles avaient disparu, mais je n'avais rien fait de spécial.

J'ai regardé un peu sur le net et cela ne viendrait pas du fait que itoa (fct de conversion int >> char *) est une fonction privée alors il faut la définir avant son utilisation donc le mieux est de la mettre au debut du fichier, donc faire un prototype. Mais avec le SDL.h cela devrait être bon je pense.

Merci du coup de main car c'est mon premier projet d'étude en algorithme et j'avoue que je suis un peu perdu avec ce gros SDL.c !!