erreur : segmentation fault

**Rémi1995** · 02/07/2012, 16h35

Bonjour,
voila je suis entrain de coder ça

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
fichiers.c
----------
 
Par Rémi
Rôle : fonctions de lecture / écriture de fichiers de niveau.
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
#include "constantes.h"
#include "fichiers.h"
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE *fichier = NULL;
 
 
            char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = "";
    int i = 0, j = 0, n = 0;
fichier = fopen("test.txt", "r+");
if(!fichier){
    fprintf(stderr,"No such file or directory : %s !");
    exit(EXIT_FAILURE);
}
else
{
 
       n = fgetc(fichier);
 switch(n)
    {
        case '1':
            fichier = fopen("niveau.lvl", "r");
 
            break;
        case '2':
            fichier = fopen("niveau1.lvl", "r");
 
            break;
        case '3':
            fichier = fopen("niveau2.lvl", "r");
 
            break;
        case '4':
            fichier = fopen("niveau3.lvl", "r");
 
            break;
 
}
 
        fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
        for(i = 0; i < NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j < NB_BLOCS_HAUTEUR; j++)
            {
                switch(ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
                {
                    case '0':
                        niveau[j][i] = 0;
                        break;
                    case '1':
                        niveau[j][i] = 1;
                        break;
                    case '2':
                        niveau[j][i] = 2;
                        break;
                    case '3':
                        niveau[j][i] = 3;
                        break;
                    case '4':
                        niveau[j][i] = 4;
                        break;
                }
            }
        }
 
        fclose(fichier);
 
 
}
 
 
 
    return 1;
    }
 
    int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    int i = 0, j = 0;
 
    fichier = fopen("niveaux.lvl", "w");
    if(fichier != NULL)
    {
        for(i = 0; i < NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j < NB_BLOCS_HAUTEUR; j++)
            {
                fprintf(fichier, "%d", niveau[j][i]);
            }
        }
 
        fclose(fichier);
    }
    else
    {
        printf("Impossible d'ouvrir le fichier niveaux.lvl");
        return 0;
    }
 
    return 1;
}

et quand je veux y jouer dans la console il m'affiche segmentation fault
merci d'avance

**MythOnirie** · 02/07/2012, 16h54

Dans ta fonction int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR]), tu ouvre un second fichier sans avoir refermé le premier. Je ne sais pas si ça vient de là, mais ça t'empêche de refermer le premier et donc de libérer la mémoire allouée.

**ternel** · 02/07/2012, 16h55

Sans avoir beaucoup regardé, j'accuse fgets(), qui est aussi dangereuse que gets().

Par ailleurs, les switchs sont faux (point de vue qualité du code) car n'ont pas pas de default.

**Rémi1995** · 02/07/2012, 18h00

alors qu'est ce qui vaux mieux mettre ?

**Neckara** · 02/07/2012, 20h08

Envoyé par leternel

Sans avoir beaucoup regardé, j'accuse fgets(), qui est aussi dangereuse que gets().

Non, relis le man :

Envoyé par http://man.developpez.com/man3/fgets.3.php

char * fgets (char * s, int size, FILE * stream);
fgets() lit au plus size - 1

Au contraire, il est même conseillé d'utiliser fgets plutôt que gets.

Envoyé par leternel

Par ailleurs, les switchs sont faux (point de vue qualité du code) car n'ont pas pas de default.

ça dépend, si le fichier ouvert est un fichier formaté, il n'y a pas besoin d'avoir un default vu qu'on est assuré qu'il n'y aura jamais d'autres valeurs que celles prévues.

Code :

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

1
2
3
4
5
6
7
for(i = 0; i < NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j < NB_BLOCS_HAUTEUR; j++)
            {
                 //....
            }
         }

Tu ne sais pas si tu as lu correctement et si il y avait bien ce nombre de caractère lus.

Code :

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

1
2
3
4
5
 
for(int i=0; ligneFichier[i] ; i++)
{
           //....
}

Tes switch sont inutiles :

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
n = fgetc(fichier);
 switch(n)
    {
        case '1':
            fichier = fopen("niveau.lvl", "r");
 
            break;
        case '2':
            fichier = fopen("niveau1.lvl", "r");
 
            break;
        case '3':
            fichier = fopen("niveau2.lvl", "r");
 
            break;
        case '4':
            fichier = fopen("niveau3.lvl", "r");
 
            break;
 
}

Il vaut mieux faire :

Code :

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

1
2
3
char * file[11];
sscanf(file, "niveau%c.lvl", n);
fichier = fopen(file);

De même :

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
switch(ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
                {
                    case '0':
                        niveau[j][i] = 0;
                        break;
                    case '1':
                        niveau[j][i] = 1;
                        break;
                    case '2':
                        niveau[j][i] = 2;
                        break;
                    case '3':
                        niveau[j][i] = 3;
                        break;
                    case '4':
                        niveau[j][i] = 4;
                        break;
                }

C'est plus pratique de faire :

Code :

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

1
2
 
niveau[j][i] = ligneFichier[(i * NB_BLOCS_LARGEUR) + j] - '0';

De plus :

Code :

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

1
2
3
4
5
6
7
8
for(i = 0; i < NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j < NB_BLOCS_HAUTEUR; j++)
            {
                    //....
            } 
 
}

On a pas forcément tout lu correctement :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int i=0;
for(; ligneFichier[i] ; i++)
{
       //...
}
if(i != NB_BLOCS_HAUTEUR * NB_BLOCS_LARGEUR )
{
           //erreur de lecture.
}

Sinon tu peux stocker tes données en binaire ainsi tu pourra remplir ton tableau d'une traite avec la fonction fread.
Et tes fichiers seront plus petits.

**Rémi1995** · 02/07/2012, 21h05

Si je veux le stoker en binaire je fais comment ? et le code je n'arrive pas à le faire marcher
le voici

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
/*fichiers.c
----------
 
Par Rémi
Rôle : fonctions de lecture / écriture de fichiers de niveau.
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
#include "constantes.h"
#include "fichiers.h"
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE *fichier = NULL;
 
 
            char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = "";
    int i = 0, j = 0, n = 0;
fichier = fopen("test.txt", "r+");
if(!fichier){
    fprintf(stderr,"No such file or directory : %s !");
    exit(EXIT_FAILURE);
}
else
{
 n = fgetc(fichier);
       fclose(fichier);
 
 
char * file[11];
sscanf(file, "niveau%c.lvl", n);
fichier = fopen(file,"r");
 
        fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
        for(i = 0; i < NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j < NB_BLOCS_HAUTEUR; j++)
            {
                niveau[j][i] = ligneFichier[(i * NB_BLOCS_LARGEUR) + j] - '0';
            }
        }
 
        fclose(fichier);
 
 
}
 
 
 
    return 1;
    }
 
    int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    int i = 0, j = 0;
 
    fichier = fopen("niveaux.lvl", "w");
    if(fichier != NULL)
    {
        for(i = 0; i < NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j < NB_BLOCS_HAUTEUR; j++)
            {
                fprintf(fichier, "%d", niveau[j][i]);
            }
        }
 
        fclose(fichier);
    }
    else
    {
        printf("Impossible d'ouvrir le fichier niveaux.lvl");
        return 0;
    }
 
    return 1;
}

et voici 2 fois la même erreur : /usr/include/stdio.h|435|note: expected ‘const char * __restrict__’ but argument is of type ‘char **’|

on dirai que ça vient de

Code :

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

1
2
sscanf(file, "niveau%c.lvl", n);
fichier = fopen(file,"r");

merci encore de m'aider

**Neckara** · 02/07/2012, 21h14

Lors du fopen, tu rajoute "b".
Ainsi tu aura : "rb", "wb", "ab", ....

Tu pourras ainsi écrire tout ton tableau avec fwrite en une seule fois et le charger avec fread en un seul coup.

**Rémi1995** · 02/07/2012, 21h22

et je fais comme ça

Code :

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

1
2
3
4
5
fichier = fopen("test.txt", "rb");
for (int i = 0, i<=20, i++)
{
int ni[20] = fwrite (fichier) 
}

non ?

**Neckara** · 02/07/2012, 21h39

Quand tu ne connais pas une fonction, utilise le man :
http://man.developpez.com/man3/fread.3.php

**Rémi1995** · 02/07/2012, 22h39

Code :

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

1
2
3
4
5
#include <stdio.h>
size_t fread (void *ptr, size_t size, size_t nmemb, FILE *stream);
 
int tableau[20] = fread( &var , sizeof(var) , 1 , fichier );
;

est ce que s'est bon et sinon si vous pouvez me donner un exemple ça serai sympa
merci d’avance

**Neckara** · 03/07/2012, 08h43

Envoyé par Rémi1995

Code :

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

1
2
3
4
5
#include <stdio.h>
size_t fread (void *ptr, size_t size, size_t nmemb, FILE *stream);

int tableau[20] =  /* fread retourne le nombre d'éléments lus cf man*/fread(/* Où est déclaré var ?*/ &var , sizeof(var) , 1 , /* Où est déclaré fichier ?*/ fichier );
;

**Rémi1995** · 03/07/2012, 09h17

alors il faut faire comme ça ?

Code :

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

1
2
3
4
 
#include <stdio.h>
 var = fgetc(fichier);
 fread( &var , sizeof(var) , 1 , fichier );

non ?
et pour
mon segmentation fault j'ai réussi à trouver ça

==3046== Memcheck, a memory error detector
==3046== Copyright (C) 2002-2010, and GNU GPL'd, by Julian Seward et al.
==3046== Using Valgrind-3.6.1 and LibVEX; rerun with -h for copyright info
==3046== Command: ./jeu
==3046==
==3046== Conditional jump or move depends on uninitialised value(s)
==3046== at 0x4356D19: inflateReset2 (in /lib/i386-linux-gnu/libz.so.1.2.3.4)
==3046== by 0x4356E0C: inflateInit2_ (in /lib/i386-linux-gnu/libz.so.1.2.3.4)
==3046== by 0x4356E92: inflateInit_ (in /lib/i386-linux-gnu/libz.so.1.2.3.4)
==3046== by 0x4ED07A4: png_create_read_struct_2 (in /lib/i386-linux-gnu/libpng12.so.0.44.0)
==3046== by 0x4ED0989: png_create_read_struct (in /lib/i386-linux-gnu/libpng12.so.0.44.0)
==3046== by 0x40CF333: IMG_LoadPNG_RW (in /usr/lib/libSDL_image-1.2.so.0.8.2)
==3046== by 0x40CA9CA: IMG_LoadTyped_RW (in /usr/lib/libSDL_image-1.2.so.0.8.2)
==3046== by 0x40CAAE2: IMG_Load (in /usr/lib/libSDL_image-1.2.so.0.8.2)
==3046== by 0x8048BEC: jouer (jeu.c:32)
==3046== by 0x8048A90: main (main.c:54)
==3046==
==3046== Invalid read of size 4
==3046== at 0x4146CAD: getc (getc.c:40)
==3046== by 0x8049854: chargerNiveau (fichiers.c:29)
==3046== by 0x8048C3F: jouer (jeu.c:41)
==3046== by 0x8048A90: main (main.c:54)
==3046== Address 0x0 is not stack'd, malloc'd or (recently) free'd
==3046==
==3046==
==3046== HEAP SUMMARY:
==3046== in use at exit: 564,560 bytes in 576 blocks
==3046== total heap usage: 15,517 allocs, 14,941 frees, 2,713,173 bytes allocated
==3046==
==3046== LEAK SUMMARY:
==3046== definitely lost: 517 bytes in 9 blocks
==3046== indirectly lost: 4,632 bytes in 42 blocks
==3046== possibly lost: 0 bytes in 0 blocks
==3046== still reachable: 559,411 bytes in 525 blocks
==3046== suppressed: 0 bytes in 0 blocks
==3046== Rerun with --leak-check=full to see details of leaked memory
==3046==
==3046== For counts of detected and suppressed errors, rerun with: -v
==3046== Use --track-origins=yes to see where uninitialised values come from
==3046== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 129 from 14)

Erreur de segmentation
quand je le lance

**Neckara** · 03/07/2012, 09h35

Il faudrait nous montrer tous les fichiers dont il est question.

Code :

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

1
2
var = fgetc(fichier);
 fread( &var , sizeof(var) , 1 , fichier );

Qu'essayes-tu de faire ?

**Rémi1995** · 03/07/2012, 09h45

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
/*
main.c
-----
Rôle : menu du jeu. Permet de choisir entre l'éditeur et le jeu lui-même.
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
#include "constantes.h"
#include "jeu.h"
#include "editeur.h"
 
 
 
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *menu = NULL;
    SDL_Rect positionMenu;
    SDL_Event event;
 
    int continuer = 1;
 
    SDL_Init(SDL_INIT_VIDEO);
 
    SDL_WM_SetIcon(IMG_Load("caisse.jpg"), NULL); // L'icône doit être chargée avant SDL_SetVideoMode
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("Mario Sokoban", NULL);
 
    menu = IMG_Load("menu.jpg");
    positionMenu.x = 0;
    positionMenu.y = 0;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE: // Veut arrêter le jeu
                        continuer = 0;
                        break;
                    case SDLK_KP1: // Demande à jouer
                        jouer(ecran);
                        break;
                    case SDLK_KP2: // Demande l'éditeur de niveaux
                        editeur(ecran);
                        break;
                }
                break;
        }
 
        // Effacement de l'écran
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
        SDL_BlitSurface(menu, NULL, ecran, &positionMenu);
        SDL_Flip(ecran);
    }
 
    SDL_FreeSurface(menu);
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
/*
jeu.c
-----
 
Par mateo21
 
Rôle : fonctions du jeu.
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
#include "constantes.h"
#include "jeu.h"
 
void jouer(SDL_Surface* ecran)
{
    SDL_Surface *mario[4] = {NULL}; // 4 surfaces pour chacune des directions de mario
    SDL_Surface *mur = NULL, *caisse = NULL, *caisseOK = NULL, *objectif = NULL, *marioActuel = NULL;
    SDL_Rect position, positionJoueur;
    SDL_Event event;
 
    int continuer = 1, objectifsRestants = 0,i = 0, j = 0;
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
 
    // Chargement des sprites (décors, personnage...)
    mur = IMG_Load("mur.jpg");
    caisse = IMG_Load("caisse.jpg");
    caisseOK = IMG_Load("caisse_ok.jpg");
    objectif = IMG_Load("objectif.png");
    mario[BAS] = IMG_Load("mario_bas.gif");
    mario[GAUCHE] = IMG_Load("mario_gauche.gif");
    mario[HAUT] = IMG_Load("mario_haut.gif");
    mario[DROITE] = IMG_Load("mario_droite.gif");
 
    marioActuel = mario[BAS]; // Mario sera dirigé vers le bas au départ
 
    // Chargement du niveau
    if (!chargerNiveau(carte))
        exit(EXIT_FAILURE); // On arrête le jeu si on n'a pas pu charger le niveau
 
    // Recherche de la position de Mario au départ
    for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
        {
            if (carte[i][j] == MARIO) // Si Mario se trouve à cette position sur la carte
            {
                positionJoueur.x = i;
                positionJoueur.y = j;
                carte[i][j] = VIDE;
            }
        }
    }
 
    // Activation de la répétition des touches
    SDL_EnableKeyRepeat(100, 100);
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
switch(event.type)
{
    case SDL_QUIT:
        continuer = 0;
        break;
    case SDL_KEYDOWN:
        switch(event.key.keysym.sym)
        {
            case SDLK_ESCAPE:
                continuer = 0;
                break;
            case SDLK_UP:
                marioActuel = mario[HAUT];
                deplacerJoueur(carte, &positionJoueur, HAUT);
                break;
            case SDLK_DOWN:
                marioActuel = mario[BAS];
                deplacerJoueur(carte, &positionJoueur, BAS);
                break;
            case SDLK_RIGHT:
                marioActuel = mario[DROITE];
                deplacerJoueur(carte, &positionJoueur, DROITE);
                break;
            case SDLK_LEFT:
                marioActuel = mario[GAUCHE];
                deplacerJoueur(carte, &positionJoueur, GAUCHE);
                break;
        }
        break;
}
 
        // Effacement de l'écran
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
 
        // Placement des objets à l'écran
        objectifsRestants = 0;
 
        for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
        {
            for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
            {
                position.x = i * TAILLE_BLOC;
                position.y = j * TAILLE_BLOC;
 
                switch(carte[i][j])
                {
                    case MUR:
                        SDL_BlitSurface(mur, NULL, ecran, &position);
                        break;
                    case CAISSE:
                        SDL_BlitSurface(caisse, NULL, ecran, &position);
                        break;
                    case CAISSE_OK:
                        SDL_BlitSurface(caisseOK, NULL, ecran, &position);
                        break;
                    case OBJECTIF:
                        SDL_BlitSurface(objectif, NULL, ecran, &position);
                        objectifsRestants = 1;
                        break;
                }
            }
        }
 
        // Si on n'a trouvé aucun objectif sur la carte, c'est qu'on a gagné
        if (!objectifsRestants)
            continuer = 0;
 
        // On place le joueur à la bonne position
        position.x = positionJoueur.x * TAILLE_BLOC;
        position.y = positionJoueur.y * TAILLE_BLOC;
        SDL_BlitSurface(marioActuel, NULL, ecran, &position);
 
 
 
        SDL_Flip(ecran);
    }
 
    // Désactivation de la répétition des touches (remise à 0)
    SDL_EnableKeyRepeat(0, 0);
 
    // Libération des surfaces chargées
    SDL_FreeSurface(mur);
    SDL_FreeSurface(caisse);
    SDL_FreeSurface(caisseOK);
    SDL_FreeSurface(objectif);
    for (i = 0 ; i < 4 ; i++)
        SDL_FreeSurface(mario[i]);
}
 
void deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction)
{
    switch(direction)
    {
        case HAUT:
            if (pos->y - 1 < 0) // Si le joueur dépasse l'écran, on arrête
                break;
            if (carte[pos->x][pos->y - 1] == MUR) // S'il y a un mur, on arrête
                break;
            // Si on veut pousser une caisse, il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse, ou la limite du monde)
            if ((carte[pos->x][pos->y - 1] == CAISSE || carte[pos->x][pos->y - 1] == CAISSE_OK) &&
                (pos->y - 2 < 0 || carte[pos->x][pos->y - 2] == MUR ||
                carte[pos->x][pos->y - 2] == CAISSE || carte[pos->x][pos->y - 2] == CAISSE_OK))
                break;
 
            // Si on arrive là, c'est qu'on peut déplacer le joueur !
            // On vérifie d'abord s'il y a une caisse à déplacer
            deplacerCaisse(&carte[pos->x][pos->y - 1], &carte[pos->x][pos->y - 2]);
 
            pos->y--; // On peut enfin faire monter le joueur (oufff !)
            break;
 
 
        case BAS:
            if (pos->y + 1 >= NB_BLOCS_HAUTEUR)
                break;
            if (carte[pos->x][pos->y + 1] == MUR)
                break;
 
            if ((carte[pos->x][pos->y + 1] == CAISSE || carte[pos->x][pos->y + 1] == CAISSE_OK) &&
                (pos->y + 2 >= NB_BLOCS_HAUTEUR || carte[pos->x][pos->y + 2] == MUR ||
                carte[pos->x][pos->y + 2] == CAISSE || carte[pos->x][pos->y + 2] == CAISSE_OK))
                break;
 
 
            deplacerCaisse(&carte[pos->x][pos->y + 1], &carte[pos->x][pos->y + 2]);
 
            pos->y++;
            break;
 
 
        case GAUCHE:
            if (pos->x - 1 < 0)
                break;
            if (carte[pos->x - 1][pos->y] == MUR)
                break;
 
            if ((carte[pos->x - 1][pos->y] == CAISSE || carte[pos->x - 1][pos->y] == CAISSE_OK) &&
                (pos->x - 2 < 0 || carte[pos->x - 2][pos->y] == MUR ||
                carte[pos->x - 2][pos->y] == CAISSE || carte[pos->x - 2][pos->y] == CAISSE_OK))
                break;
 
 
            deplacerCaisse(&carte[pos->x - 1][pos->y], &carte[pos->x - 2][pos->y]);
 
            pos->x--;
            break;
 
 
        case DROITE:
            if (pos->x + 1 >= NB_BLOCS_LARGEUR)
                break;
            if (carte[pos->x + 1][pos->y] == MUR)
                break;
 
            if ((carte[pos->x + 1][pos->y] == CAISSE || carte[pos->x + 1][pos->y] == CAISSE_OK) &&
                (pos->x + 2 >= NB_BLOCS_LARGEUR || carte[pos->x + 2][pos->y] == MUR ||
                carte[pos->x + 2][pos->y] == CAISSE || carte[pos->x + 2][pos->y] == CAISSE_OK))
                break;
 
            deplacerCaisse(&carte[pos->x + 1][pos->y], &carte[pos->x + 2][pos->y]);
 
            pos->x++;
            break;
    }
}
 
void deplacerCaisse(int *premiereCase, int *secondeCase)
{
    if (*premiereCase == CAISSE || *premiereCase == CAISSE_OK)
    {
        if (*secondeCase == OBJECTIF)
            *secondeCase = CAISSE_OK;
        else
            *secondeCase = CAISSE;
 
        if (*premiereCase == CAISSE_OK)
            *premiereCase = OBJECTIF;
        else
            *premiereCase = VIDE;
    }
}
 
/*
fichiers.c
----------
 
Par:
 
remi
 
Rôle :
fonctions de lecture / écriture de fichiers de niveau.
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include "constantes.h"
#include "fichiers.h"
 
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE *fichier = NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = "";
    int i = 0, j = 0, n = 0;
 
if(!fichier){
    fprintf(stderr,"No such file or directory : %s !",chaine);
    exit(EXIT_FAILURE);
}
 
char * file[11];
sscanf(file, "niveau%c.lvl", n);
fichier = fopen(file);
 
 fichier = fopen("test.txt", "r+");
if(fichier!=0)
{
 
 
//on lis le fichier puis on l'enregiste dans la variable jeu
 
    jeu = fgetc(fichier);
}
 
 
 
    if(fichier != NULL)
    {
        fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
        for(i = 0; i < NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j < NB_BLOCS_HAUTEUR; j++)
            {
             niveau[j][i] = ligneFichier[(i * NB_BLOCS_LARGEUR) + j] - '0';
            }
 
}
        }
 
        fclose(fichier);
    }
    else
    {
        printf("Impossible d'ouvrir le fichier niveau");
        return 0;
    }
 
    return 1;
}
 
int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    int i = 0, j = 0;
 
    fichier = fopen("niveaux.lvl", "w");
    if(fichier != NULL)
    {
        for(i = 0; i < NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j < NB_BLOCS_HAUTEUR; j++)
            {
                fprintf(fichier, "%d", niveau[j][i]);
            }
        }
 
        fclose(fichier);
    }
    else
    {
        printf("Impossible d'ouvrir le fichier niveaux.lvl");
        return 0;
    }
 
    return 1;
}
/*
editeur.c
---------
 
Par mateo21
 
Rôle : gestion de l'éditeur de niveaux.
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
#include "constantes.h"
#include "editeur.h"
#include "fichiers.h"
 
void editeur(SDL_Surface* ecran)
{
    SDL_Surface *mur = NULL, *caisse = NULL, *objectif = NULL, *mario = NULL;
    SDL_Rect position;
    SDL_Event event;
 
    int continuer = 1, clicGaucheEnCours = 0, clicDroitEnCours = 0;
    int objetActuel = MUR, i = 0, j = 0;
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
 
    // Chargement des objets et du niveau
    mur = IMG_Load("mur.jpg");
    caisse = IMG_Load("caisse.jpg");
    objectif = IMG_Load("objectif.png");
    mario = IMG_Load("mario_bas.gif");
 
    if (!chargerNiveau(carte))
        exit(EXIT_FAILURE);
 
    // Boucle infinie de l'éditeur
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_MOUSEBUTTONDOWN:
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
                    carte[event.button.x / TAILLE_BLOC][event.button.y / TAILLE_BLOC] = objetActuel;
                    clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                }
                else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                {
                    carte[event.button.x / TAILLE_BLOC][event.button.y /TAILLE_BLOC] = VIDE;
                    clicDroitEnCours = 1;
                }
                break;
            case SDL_MOUSEBUTTONUP: // On désactive le booléen qui disait qu'un bouton était enfoncé
                if (event.button.button == SDL_BUTTON_LEFT)
                    clicGaucheEnCours = 0;
                else if (event.button.button == SDL_BUTTON_RIGHT)
                    clicDroitEnCours = 0;
                break;
            case SDL_MOUSEMOTION:
                if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                {
                    carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = objetActuel;
                }
                else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                {
                    carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = VIDE;
                }
                break;
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    case SDLK_s:
                        sauvegarderNiveau(carte);
                        break;
                    case SDLK_c:
                        chargerNiveau(carte);
                        break;
                    case SDLK_KP1:
                        objetActuel = MUR;
                        break;
                    case SDLK_KP2:
                        objetActuel = CAISSE;
                        break;
                    case SDLK_KP3:
                        objetActuel = OBJECTIF;
                        break;
                    case SDLK_KP4:
                        objetActuel = MARIO;
                        break;
                }
                break;
        }
 
        // Effacement de l'écran
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
 
        // Placement des objets à l'écran
        for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
        {
            for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
            {
                position.x = i * TAILLE_BLOC;
                position.y = j * TAILLE_BLOC;
 
                switch(carte[i][j])
                {
                    case MUR:
                        SDL_BlitSurface(mur, NULL, ecran, &position);
                        break;
                    case CAISSE:
                        SDL_BlitSurface(caisse, NULL, ecran, &position);
                        break;
                    case OBJECTIF:
                        SDL_BlitSurface(objectif, NULL, ecran, &position);
                        break;
                    case MARIO:
                        SDL_BlitSurface(mario, NULL, ecran, &position);
                        break;
                }
            }
        }
 
        // Mise à jour de l'écran
        SDL_Flip(ecran);
    }
 
    SDL_FreeSurface(mur);
    SDL_FreeSurface(caisse);
    SDL_FreeSurface(objectif);
    SDL_FreeSurface(mario);
}

et pour

Qu'essayes-tu de faire ?

j'essaye de lie un fichier en binaire sauf que je n'y arrive pas

**Neckara** · 03/07/2012, 10h06

Code :

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

1
2
3
fichier = fopen(file);
 
 fichier = fopen("test.txt", "r+");

?????

Code :

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

jeu = fgetc(fichier);

où est déclaré la variable jeu ?

Sinon :

Code :

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

1
2
3
4
5
6
7
char var = fgetc(fichier);
//OU exclusif
char var;
if(! fread( &var , sizeof(var) , 1 , fichier ) )
{
        //erreur;
}

**Rémi1995** · 03/07/2012, 10h39

Code :

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

1
2
3
4
5
6
7
8
9
char var = fgetc(fichier);
//OU exclusif
char var;
if(! fread( &var , sizeof(var) , 1 , fichier ) )
{
        //erreur;
 
}
// et la je met quoi ?

**Neckara** · 03/07/2012, 10h42

Il ne suffit pas de copier/coller il faut aussi chercher à comprendre.

Ou exclusif signifie l'un ou l'autre mais pas les deux.
Pour ce que tu met après, j'en sais rien, c'est à toi de dire ce que tu veux faire avec ta variable var.

**Rémi1995** · 03/07/2012, 11h07

Donc si j'a bien compris il faut que je fasse

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
 
char var = fgetc(fichier);
//OU exclusif
char var;
if(! fread( &var , sizeof(var) , 1 , fichier ) )
{
        //erreur;
 
}
else 
{
char * file[11];
sscanf(file, "niveau%c.lvl", var);
fichier = fopen(file,"r");
if(!Niveau){
    fprintf(stderr,"No such file or directory : %s !",chaine);
    exit(EXIT_FAILURE);
}
//la suite 
}

**Neckara** · 03/07/2012, 11h14

Code :

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

fichier = fopen(file,"r");

Il faudrait peut-être fermer fichier avant d'en ouvrir un autre non ?

**Rémi1995** · 03/07/2012, 14h44

ça y est je l'ai fais mais mes erreurs sont toujours la et je n'arrive pas à trouver la solution

/usr/include/stdio.h|435|note: expected ‘const char * __restrict__’ but argument is of type ‘char **’|

/usr/include/stdio.h|269|note: expected ‘const char * __restrict__’ but argument is of type ‘char **’|

erreur : segmentation fault

C

Discussions similaires

Partager

Partager