Collision avec des murs

Version imprimable

Bonsoir,

tout d'abord j'espère que je ne me suis pas trompé de "sous-forum" pour ma question. Si c'est le cas, désolé. Je viens d'arriver sur ce forum.

Je suis entrain de créer un jeu en C avec la bibliothèque SDL. L'idée est simple, un parcours s'affiche pendant quelques secondes, puis le joueur doit refaire le parcours.
Afficher le parcours ne me pose (plus) de problème.
Mais maintenant je veux faire en sorte que mon petit mario ne traverse pas les murs. Et c'est là que je bloque.
Pour afficher la carte, j'utilise un tableau qui à chaque coordonnées indiquées place l'image.
L'idée pour mon code, c'est de parcourir le tableau et si au coordonnées de mon mario et que à la même position on a les coordonnées d'un mur, et bien ça ne marche pas. le jeu démarre et au moment de passer a travers un mur, la fenêtre du jeu se ferme...

Et pour que vous puissiez comprendre ce que j'ai essayer de faire, voici mon code:
(la partie sur la gestion des collision est dans le while(continuer) { }

Code:

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
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <windows.h>
 
 
 
#define TAILLE_BLOC         34 // Taille d'un bloc (carré) en pixels
#define NB_BLOCS_LARGEUR    12
#define NB_BLOCS_HAUTEUR    12
#define LARGEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_LARGEUR
#define HAUTEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_HAUTEUR
 
enum {HAUT, BAS, GAUCHE, DROITE};
enum {VIDE, MUR, SOL, MARIO};
 
int main(int argc, char *argv[])
{
 
    SDL_Surface *mur=NULL, *mario_bas=NULL ,*mario_haut=NULL ,*mario_gauche=NULL ,*mario_droite=NULL ,*ecran=NULL, *sol=NULL;
    SDL_Rect position, positionMario, stuff;
    SDL_Event event;
 
    int x=0, y=6, machinX=0, machinY=0;
    int continuer = 1;
 
 
 
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR]={0};
    SDL_Init(SDL_INIT_VIDEO);
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("maze", NULL);
 
    mur=SDL_LoadBMP("mur.BMP");
    sol=SDL_LoadBMP("caisse.BMP");
    mario_bas=SDL_LoadBMP("mario_bas.bmp");
    mario_haut=SDL_LoadBMP("mario_haut.bmp");
    mario_droite=SDL_LoadBMP("mario_droite.bmp");
    mario_gauche=SDL_LoadBMP("mario_gauche.bmp");
 
    SDL_SetColorKey(mario_bas, SDL_SRCCOLORKEY, SDL_MapRGB(mario_bas->format, 0, 0, 255));
    SDL_SetColorKey(mario_haut, SDL_SRCCOLORKEY, SDL_MapRGB(mario_haut->format, 255, 255, 255));
    SDL_SetColorKey(mario_droite, SDL_SRCCOLORKEY, SDL_MapRGB(mario_droite->format, 255, 255, 255));
    SDL_SetColorKey(mario_gauche, SDL_SRCCOLORKEY, SDL_MapRGB(mario_gauche->format, 255, 255, 255));
 
    positionMario.x=0;
    positionMario.y=TAILLE_BLOC*6;
 
    SDL_EnableKeyRepeat(150, 150);
 
    //On veut afficher une premiere fois la carte pendant un temps donnee (ex: 1 seconde)
 
    FILE* fichier=NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR+1]={0};
    int i=0, j=0;
    fichier =fopen("niveau.txt","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++)
            {
                switch(ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
                {
                    case'0':
                        carte[i][j]=0;
                        break;
                    case'1':
                        carte[i][j]=1;
                        break;
                    case '2':
                        carte[i][j]=2;
                        break;
                }
            }
        }
    fclose(fichier);
 
    //affichage de la carte a l ecran
    int k=0, m=0;
        for (k = 0 ; k < NB_BLOCS_LARGEUR ; k++)
        {
            for (m = 0 ; m < NB_BLOCS_HAUTEUR ; m++)
            {
                position.x = k*TAILLE_BLOC;
                position.y = m*TAILLE_BLOC;
 
                switch(carte[k][m])
                {
                case MUR:
                    SDL_BlitSurface(mur,NULL,ecran,&position);
                    break;
                case SOL:
                    SDL_BlitSurface(sol,NULL,ecran,&position);
                    break;
                }
            }
        }
    SDL_BlitSurface(mario,NULL,ecran,&positionMario);
    SDL_Flip(ecran);
 
    Sleep(1500);       // affichage du parcours pendant x milliseconde(s)
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
    SDL_Flip(ecran);
 
    SDL_BlitSurface(sol,NULL,ecran,&positionMario);
    SDL_BlitSurface(mario_bas,NULL,ecran,&positionMario); // position de Mario au depart
 
 
 
    // a partir d ici le joueur ne vois plus que mario et dois se diriger vers la sortie a l aveugle
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
        case SDL_QUIT:
            continuer=0;
            break;
        case SDL_KEYDOWN:
            switch(event.key.keysym.sym)
            {
                case SDLK_UP://deplacement vers le haut
                    if(carte[positionMario.x][positionMario.y-TAILLE_BLOC]==MUR))
                        break;
                        y--;
                        positionMario.y = y * TAILLE_BLOC;
                        //Gros truc moche pour afficher le parcours derriere et en dessous de mario
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX;
                        stuff.y=machinY+TAILLE_BLOC;
                        /*SDL_BlitSurface(sol,NULL,ecran,&stuff);             // affichage du parquet sur la position precedente de mario
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);*/     // affichage du parquet en dessous de mario
                        SDL_BlitSurface(mario_haut,NULL,ecran,&positionMario);
                        break;
 
 
                    case SDLK_DOWN://deplacement vers le bas
                    if(carte[positionMario.x][positionMario.y+TAILLE_BLOC]==MUR))
                        break;
                        y++;
                        positionMario.y = y * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX;
                        stuff.y=machinY-TAILLE_BLOC;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        SDL_BlitSurface(mario_bas,NULL,ecran,&positionMario);
                        break;
                    case SDLK_RIGHT://deplacement vers la droite
                    if(carte[positionMario.x+TAILLE_BLOC][positionMario.y]==MUR))
                        break;
                        x++;
                        positionMario.x = x * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX-TAILLE_BLOC;
                        stuff.y=machinY;
                        /*SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);*/
                        SDL_BlitSurface(mario_droite,NULL,ecran,&positionMario);
                        break;
                    case SDLK_LEFT://deplacement vers la gauche
                    if(carte[positionMario.x-TAILLE_BLOC][positionMario.y]==MUR))
                        break;
                        x--;
                        positionMario.x = x * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX+TAILLE_BLOC;
                        stuff.y=machinY;
                        //SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        //SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        SDL_BlitSurface(mario_gauche,NULL,ecran,&positionMario);
                        break;
                    case SDLK_ESCAPE://sortie du programme
                        continuer = 0;
                        break;
                    default: break;
            }
        }
        SDL_Flip(ecran);
 
 
 
 
    }
    SDL_FreeSurface(mur);
    SDL_FreeSurface(mario_droite);
    SDL_FreeSurface(sol);
    SDL_Quit();
 
    return EXIT_SUCCESS;
}

(version provisoire, je le mettrai bien en forme à la fin et virant les variables globales, en faisant des fonctions en dehors du main, etc. Mais déjà j'aimerais que cette V1 fonctionne, surtout la collision! )

Merci pour votre aide!;)

08/12/2019, 11h05
LittleWhite

Bonjour,

Citation:

Envoyé par Niko44380

la fenêtre du jeu se ferme...

Je conseille d'utiliser un débogueur, pour comprendre pourquoi le programme crashe.

Citation:

(version provisoire, je le mettrai bien en forme à la fin et virant les variables globales, en faisant des fonctions en dehors du main, etc.

Dommage, le fait de faire des fonctions aurait beaucoup aidé à vous relire et vous aurez beaucoup aidé pour vous y retrouver (ou pour simplifier certains codes).

Code:

mur=SDL_LoadBMP("mur.BMP");

Pas de vérification des codes d'erreur, c'est dommage et cela fait perdre du temps.

Code:

SDL_EnableKeyRepeat(150, 150);

et

Code:

SDL_WaitEvent(&event);

Peut être c'est voulu dans le gameplay (en réalité, c'est très très rare que cela le soit), mais un SDL_WaitEvent() bloque le programme (met le programme en pause). Dans un jeu, on veut rarement, voir jamais un tel comportement.

Code:

if(carte[positionMario.x][positionMario.y-TAILLE_BLOC]==MUR))

La carte n'est pas une représentation graphique. Je veux dire, que la carte n'a aucun lien avec l'écran ou les graphismes. C'est juste de la logique. Par conséquent, lorsque vous faites -TAILLE_BLOC cela ne va pas, car la taille du bloc, c'est une taille en pixel.
Encore plus précisément (et un débogueur pourrait vous aider à mieux voir cela). La carte fait 12x12. La taille d'un bloc (en pixel) fait 34. Peut importe la position de mario, vous faites un -34 sur l'indice du tableau. Je suspecte (je suis sur) que vous sortez des bornes du tableau.
Aussi, la position du mario est en pixels, car c'est une variable utilisée pour l'affichage. Elle n'a donc aucun lien avec la carte. Il faut faire une transcription de la position à l'affichage de mario, vers une position sur la carte. Je vous laisse trouver ce calcul (simple).
Indice :

Code:

positionMario.y = y * TAILLE_BLOC;

Peut être il faudrait utiliser les variables x et y plutôt :whistle: (ou sinon, trouver le calcul, qui est notamment l'inverse de celui-ci (comment passer d'une position écran à une position sur la carte , et inversement).

Bon dev !

Bonjour, je suis le binôme de Niko44380, nous travaillons sur le même programme.
Merci de nous avoir répondu, vos conseils nous ont été utiles. En effet, les variables x et y ont été créées spécialement pour qu'elles puissent correspondre aux bornes du tableau carte.
Malheureusement, même en imposant des conditions avec x et y, le programme n'a pas l'air d'en tenir compte. J'ai pu utiliser le debugger et je confirme que x et y sont bien compris entre 0 et 11. Ainsi, je ne vois pas pourquoi il ne veut pas entrer dans notre condition. Avez-vous une idée ?
Je vous laisse un programme plus simple qui gère juste les déplacements sur une carte :

Code:

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
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
int main(int argc, char *argv[])
{
 
    #define TAILLE_BLOC         34 // Taille d'un bloc (carré) en pixels
    #define NB_BLOCS_LARGEUR    12
    #define NB_BLOCS_HAUTEUR    12
    #define LARGEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_LARGEUR
    #define HAUTEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_HAUTEUR
 
    FILE* fichier=NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR+1]={0};
    int x=0, y=6, i=0, j=0;
    int continuer = 1;
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR]={0};
 
    enum {HAUT, BAS, GAUCHE, DROITE};
    enum {VIDE, MUR, SOL, MARIO};
 
 
    SDL_Surface *mur=NULL, *mario=NULL ,*ecran=NULL, *sol=NULL;
    SDL_Rect position, positionMario;
    SDL_Event event;
    SDL_Init(SDL_INIT_VIDEO);
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("Maze", NULL);
 
    mur=SDL_LoadBMP("mur.BMP");
    sol=SDL_LoadBMP("caisse.BMP");
    mario=SDL_LoadBMP("mario_bas.bmp");
    SDL_SetColorKey(mario, SDL_SRCCOLORKEY, SDL_MapRGB(mario->format, 0, 0, 255));
 
    positionMario.x = x * TAILLE_BLOC;
    positionMario.y = y * TAILLE_BLOC;
 
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
        case SDL_QUIT:
            continuer=0;
            break;
        case SDL_KEYDOWN:
           switch(event.key.keysym.sym)
            {
                case SDLK_UP:
                        if(positionMario.y == 0 || carte[positionMario.x][positionMario.y-1] == MUR)
                        {
                            break;
                        }
                        /*if(carte[positionMario.x][positionMario.y-1] == SOL)
                        {
                            y--;
                            positionMario.y = y * TAILLE_BLOC;
                            break;0 ||
                        }*/
                        y--;
                        positionMario.y = y * TAILLE_BLOC;
                        break;
                    case SDLK_DOWN:
                        if(positionMario.y >= HAUTEUR_FENETRE-TAILLE_BLOC || carte[positionMario.x][positionMario.y+1] == MUR)
                        {
                            break;
                        }
                        /*if(carte[positionMario.x][positionMario.y+1] == SOL)
                        {
                            y++;
                            positionMario.y = y * TAILLE_BLOC;
                            break;
                        }*/
                        y++;
                        positionMario.y = y * TAILLE_BLOC;
                        break;
                    case SDLK_RIGHT:
                        if(positionMario.x >= LARGEUR_FENETRE-TAILLE_BLOC || carte[positionMario.x-1][positionMario.y] == MUR)
                        {
                            break;
                        }
                        /*if(carte[positionMario.x+1][positionMario.y] == SOL)
                        {
                            x++;
                            positionMario.x = x * TAILLE_BLOC;
                            break;
                        }*/
                        x++;
                        positionMario.x = x * TAILLE_BLOC;
                        break;
                    case SDLK_LEFT://deplacement vers la gauche
                        if(positionMario.x == 0 || carte[positionMario.x+1][positionMario.y] == MUR)
                        {
                            break;
                        }
                        /*if(carte[positionMario.x+1][positionMario.y] == SOL)
                        {
                            x--;
                            positionMario.x = x * TAILLE_BLOC;
                            break;
                        }*/
                        x--;
                        positionMario.x = x * TAILLE_BLOC;
                        break;
                    case SDLK_ESCAPE://sortie du programme
                        continuer = 0;;
                        break;
                    default: break;
            }
        }
 
        fichier =fopen("niveau.txt","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++)
            {
                switch(ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
                {
                    case'0':
                        carte[i][j]=0;
                        break;
                    case'1':
                        carte[i][j]=1;
                        break;
                    case '2':
                        carte[i][j]=2;
                        break;
                }
            }
        }
        fclose(fichier);
 
        //affichage du quadrillage a l ecran
        int k=0, m=0;
        for (k = 0 ; k < NB_BLOCS_LARGEUR ; k++)
        {
            for (m = 0 ; m < NB_BLOCS_HAUTEUR ; m++)
            {
                position.x = k*TAILLE_BLOC;
                position.y = m*TAILLE_BLOC;
 
                switch(carte[k][m])
                {
                case MUR:
                    SDL_BlitSurface(mur,NULL,ecran,&position);
                    break;
                case SOL:
                    SDL_BlitSurface(sol,NULL,ecran,&position);
                    break;
                }
            }
        }
        SDL_BlitSurface(mario,NULL,ecran,&positionMario);
        SDL_Flip(ecran);
 
    }
    SDL_FreeSurface(mur);
    SDL_Quit();
 
    return EXIT_SUCCESS;
}

Merci d'avance :)

08/12/2019, 18h50
LittleWhite

Citation:

Ainsi, je ne vois pas pourquoi il ne veut pas entrer dans notre condition. Avez-vous une idée ?

Avec le débogueur cela devrait être clair. Il suffit de mettre un point d'arrêt sur la ligne de la condition, d'afficher les variables en jeu dans la condition et vous aurez la réponse ;)

Note : quelle valeur attendez-vous, pour l'énumération MUR ?
Note 2 : je ne vois plus le code de chargement de la carte :koi:.
08/12/2019, 20h57
Captcha76

Justement, en utilisant le débogueur avec le point d'arrêt sur la condition, j'ai bien des valeurs comprises entre 0 et 11 pour x et y :(

Pour l'affichage de la carte, on utilise les 2 boucles for à la fin du programme. La première sert à traduire un fichier .txt qui est composé de 0,1 et 2 en un tableau : carte[i][j].
Ensuite, la deuxième double boucle for permet d'afficher les murs et les sols en regardant les valeurs du tableau carte. Si carte[i][j]=1, alors on affiche un mur, si carte[i][j]=2, alors ce sera un sol.
En début de programme, on utilise :

Code:

enum {VIDE, MUR, SOL, MARIO};

Cela nous permet d'avoir la valeur '1' pour MUR et la valeur '2' pour le SOL.

Je n'avais pas de doute pour x et y.
En fait, je ne suis pas certain que MUR soit réellement à 1. Pour avoir un tel enum, comme vous l'imaginez, j'aurai écrit :

Code:

enum {VIDE=0, MUR, SOL, MARIO};

De plus, votre code de lecture n'est pas cohérent, car il n'utilise pas l'enum :
Code:

1 2 3 4 5 6 7 8 9 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': carte[i][j]=0; break
au lieu d'une assignation avec :

Code:

carte[i][j]=0;

Ensuite, vous lisez le fichier à chaque itération de la boucle, c'est très mauvais. Dans cet article, j'y explique comment un jeu doit être architecturé.

On avance!

Merci beaucoup pour ton aide LittleWhite. C'était effectivement un soucis avec

Code:

if(carte[positionMario.x][positionMario.y-TAILLE_BLOC]==MUR)

On a remplacé par

Code:

if(carte[x][y-1]==MUR)

et ça marche impec! ! ! :D :D :D

Du coup maintenant j'essaye de nettoyer le code et de le rendre tout beau. Et pour ça je voudrais simplifier cette partie du code qui est vraiment bourrin

Code:

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
  while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
        case SDL_QUIT:
            continuer=0;
            break;
        case SDL_KEYDOWN:
            switch(event.key.keysym.sym)
            {
                case SDLK_UP://deplacement vers le haut
                    if(positionMario.y<0) break;//on empeche de sortir de la fenetre
                    if(carte[x][y-1]==MUR) break;
                        y--;
                        positionMario.y = y * TAILLE_BLOC;
                        //Gros truc moche pour afficher le parcours derriere et en dessous de mario
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX;
                        stuff.y=machinY+TAILLE_BLOC;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);             // affichage du parquet sur la position precedente de mario et cacher les images precedente
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);   // affichage du parquet en dessous de mario
                        SDL_BlitSurface(mario_haut,NULL,ecran,&positionMario);
                    if(carte[x][y-1]==ARRIVE) win=1;
                        break;
                    case SDLK_DOWN://deplacement vers le bas
                        if(positionMario.y+1>LARGEUR_FENETRE-TAILLE_BLOC) break;
                        if(carte[x][y+1]==MUR)
                            break;
                        y++;
                        positionMario.y = y * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX;
                        stuff.y=machinY-TAILLE_BLOC;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        SDL_BlitSurface(mario_bas,NULL,ecran,&positionMario);
                        break;
                    case SDLK_RIGHT://deplacement vers la droite
                        if(positionMario.x+1>LARGEUR_FENETRE-TAILLE_BLOC) break;
                        if(carte[x+1][y]==MUR)
                            break;
                        x++;
                        positionMario.x = x * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX-TAILLE_BLOC;
                        stuff.y=machinY;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        SDL_BlitSurface(mario_droite,NULL,ecran,&positionMario);
                        if(carte[x][y]==ARRIVE) win=1;
                        break;
                    case SDLK_LEFT://deplacement vers la gauche
                        if(positionMario.x-1<0) break;
                        if(carte[x-1][y]==MUR)
                            break;
                        x--;
                        positionMario.x = x * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX+TAILLE_BLOC;
                        stuff.y=machinY;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        SDL_BlitSurface(mario_gauche,NULL,ecran,&positionMario);
                        break;
                    case SDLK_ESCAPE://sortie du programme
                        continuer = 0;
                        break;
                    default: break;
            }
        }

La raison de stuff, machinX et machinY, c'est que quand le mario avance et donc qu'on blit l'image sur la case d'à côté, l'image de la case précédente reste. Donc on blit un sol dessus pour cacher. C'est pas très élégant.
Je pensais utiliser

Code:

1
2
3
4
 SDL_FreeSurface(mario_droite);
    SDL_FreeSurface(mario_haut);
    SDL_FreeSurface(mario_bas);
    SDL_FreeSurface(mario_gauche);

pour enlever ces images. Mais si je les met dans la boucle " while(continuer)", je n'ai plus d'images qui s'affichent...

la fonction "jeu" dans sa totalité:

Code:

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
 
void jouer(SDL_Surface *a);
 
void jouer(SDL_Surface *a)
{
    SDL_Surface *mur=NULL, *mario_bas=NULL ,*mario_haut=NULL ,*mario_gauche=NULL ,*mario_droite=NULL ,*ecran=NULL, *sol=NULL, *objectif=NULL;
    SDL_Rect position, positionMario, stuff;
    SDL_Event event;
 
    int x=0, y=6, machinX=0, machinY=0, win=0, vie=4;
    int continuer = 1;
    positionMario.x = x * TAILLE_BLOC;
    positionMario.y = y * TAILLE_BLOC;
 
 
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR]={0};
    SDL_Init(SDL_INIT_VIDEO);
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("maze", NULL);
 
    mur=SDL_LoadBMP("mur.bmp");
    sol=SDL_LoadBMP("caisse.bmp");
    objectif=SDL_LoadBMP("objectif.bmp");
    mario_bas=SDL_LoadBMP("mario_bas.bmp");
    mario_haut=SDL_LoadBMP("mario_haut.bmp");
    mario_droite=SDL_LoadBMP("mario_droite.bmp");
    mario_gauche=SDL_LoadBMP("mario_gauche.bmp");
 
    SDL_SetColorKey(mario_bas, SDL_SRCCOLORKEY, SDL_MapRGB(mario_bas->format, 0, 0, 255));
    SDL_SetColorKey(mario_haut, SDL_SRCCOLORKEY, SDL_MapRGB(mario_haut->format, 255, 255, 255));
    SDL_SetColorKey(mario_droite, SDL_SRCCOLORKEY, SDL_MapRGB(mario_droite->format, 255, 255, 255));
    SDL_SetColorKey(mario_gauche, SDL_SRCCOLORKEY, SDL_MapRGB(mario_gauche->format, 255, 255, 255));
    SDL_SetColorKey(objectif, SDL_SRCCOLORKEY, SDL_MapRGB(mario_bas->format, 255, 255, 255));
 
    positionMario.x=0;                          //position de mario au depart
    positionMario.y=TAILLE_BLOC*6;
 
    //SDL_EnableKeyRepeat(150, 150);
 
    //On veut afficher une premiere fois la carte pendant un temps donnee (ex: 1 seconde)
 
    FILE* fichier=NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR+1]={0};
    int i=0, j=0;
    fichier =fopen("niveautest.txt","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++)
            {
                switch(ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
                {
                    case'0':
                        carte[i][j]=VIDE;
                        break;
                    case'1':
                        carte[i][j]=MUR;
                        break;
                    case '2':
                        carte[i][j]=SOL;
                        break;
                    case '4':
                        carte[i][j]=ARRIVE;
                        break;
                }
            }
        }
    fclose(fichier);
 
    //affichage du quadrillage a l ecran
    int k=0, m=0;
        for (k = 0 ; k < NB_BLOCS_LARGEUR ; k++)
        {
            for (m = 0 ; m < NB_BLOCS_HAUTEUR ; m++)
            {
                position.x = k*TAILLE_BLOC;
                position.y = m*TAILLE_BLOC;
 
                switch(carte[k][m])
                {
                case MUR:
                    SDL_BlitSurface(mur,NULL,ecran,&position);
                    break;
                case SOL:
                    SDL_BlitSurface(sol,NULL,ecran,&position);
                    break;
                case ARRIVE:
                    SDL_BlitSurface(sol,NULL,ecran,&position);
                    SDL_BlitSurface(objectif,NULL,ecran,&position);
                    break;
                }
            }
        }
    //SDL_BlitSurface(mario,NULL,ecran,&positionMario);
    SDL_Flip(ecran);
 
    Sleep(1500);       // affichage du parcours pendant x milliseconde(s)
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
    SDL_Flip(ecran);
 
    SDL_BlitSurface(sol,NULL,ecran,&positionMario);
    SDL_BlitSurface(mario_bas,NULL,ecran,&positionMario); // position de Mario au depart
 
 
 
    // a partir d ici le joueur ne vois plus que mario et dois se dirige r vers la sortie a l aveugle
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
        case SDL_QUIT:
            continuer=0;
            break;
        case SDL_KEYDOWN:
            switch(event.key.keysym.sym)
            {
                case SDLK_UP://deplacement vers le haut
                    if(positionMario.y<0) break;//on empeche de sortir de la fenetre
                    if(carte[x][y-1]==MUR) break;
                        y--;
                        positionMario.y = y * TAILLE_BLOC;
                        //Gros truc moche pour afficher le parcours derriere et en dessous de mario
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX;
                        stuff.y=machinY+TAILLE_BLOC;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);             // affichage du parquet sur la position precedente de mario
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);   // affichage du parquet en dessous de mario
                        SDL_BlitSurface(mario_haut,NULL,ecran,&positionMario);
                    if(carte[x][y-1]==ARRIVE) win=1;
                        break;
                    case SDLK_DOWN://deplacement vers le bas
                        if(positionMario.y+1>LARGEUR_FENETRE-TAILLE_BLOC) break;
                        if(carte[x][y+1]==MUR)
                            break;
                        y++;
                        positionMario.y = y * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX;
                        stuff.y=machinY-TAILLE_BLOC;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        SDL_BlitSurface(mario_bas,NULL,ecran,&positionMario);
                        break;
                    case SDLK_RIGHT://deplacement vers la droite
                        if(positionMario.x+1>LARGEUR_FENETRE-TAILLE_BLOC) break;
                        if(carte[x+1][y]==MUR)
                            break;
                        x++;
                        positionMario.x = x * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX-TAILLE_BLOC;
                        stuff.y=machinY;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        SDL_BlitSurface(mario_droite,NULL,ecran,&positionMario);
                        if(carte[x][y]==ARRIVE) win=1;
                        break;
                    case SDLK_LEFT://deplacement vers la gauche
                        if(positionMario.x-1<0) break;
                        if(carte[x-1][y]==MUR)
                            break;
                        x--;
                        positionMario.x = x * TAILLE_BLOC;
                        machinX=positionMario.x;
                        machinY=positionMario.y;
                        stuff.x=machinX+TAILLE_BLOC;
                        stuff.y=machinY;
                        SDL_BlitSurface(sol,NULL,ecran,&stuff);
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        SDL_BlitSurface(mario_gauche,NULL,ecran,&positionMario);
                        break;
                    case SDLK_ESCAPE://sortie du programme
                        continuer = 0;
                        break;
                    default: break;
            }
        }
        SDL_Flip(ecran);
 
 
    }
    SDL_FreeSurface(mur);
    SDL_FreeSurface(mario_droite);
    SDL_FreeSurface(mario_haut);
    SDL_FreeSurface(mario_bas);
    SDL_FreeSurface(mario_gauche);
    SDL_FreeSurface(sol);
    SDL_Quit();
 
//    return EXIT_SUCCESS;
}

11/12/2019, 20h00
LittleWhite

Le SDL_FreeSurface n'enlève pas les images de l'écran, cela enlève les images de la mémoire (par conséquent, elles ne seront plus utilisables dans le programme).
Habituellement, on efface l'écran à chaque itération de la boucle. Du coup, pour le réafficher, il faut avoir un tableau (une carte) indiquant quelle sont les choses à afficher.
Si vous ne voulez pas passer par cette solution, alors cela ne me choque pas de blitter le sol à l'ancienne position. Par contre, le nom de la variable stuff ne me semble pas clair.

Pour réduire le code de la boucle principale, vous pouvez faire une fonction move() qui acceptera comme paramètre, la prochaine case où mario doit aller. Je pense que cela réduira de beaucoup la duplication de code ;). À vous donc, de réfléchir comment implémenter une telle chose ;).

Je vais voir comment faire ça. Pas sûr que j'ai le temps d'ici la présentation de notre programme demain.

Si jamais une âme charitable passait par là et avait la solution pour le problème suivant:
Une fois qu'on a fait tout les niveaux, la fenêtre du jeu devrait se fermer et on devrait retourner sur la fenêtre du menu principal. Mais ce n'est pas le cas. La fenêtre du jeu en lui-même se ferme mais on ne revient pas au menu. Le jeu s'arrête complètement.

code de la fonction main :

Code:

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
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <windows.h>
 
#include "constantes.h"
#include "jeu.c"
#include "jeu.h"
 
 
 
 
 
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *menu1 = NULL, *blabla=NULL;
    SDL_Rect positionMenu;
    SDL_Event event;
 
    int continuer = 1;
 
    SDL_Init(SDL_INIT_VIDEO);
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("menu", NULL);
 
    menu1 =SDL_LoadBMP("menu1.bmp");
    blabla=SDL_LoadBMP("blabla.bmp");
 
    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:
                    SDL_BlitSurface(blabla,NULL,ecran,&positionMenu); //mise en contexte du jeu
                    SDL_Flip((ecran));
                    Sleep(6000);
                    jouer(ecran,1);        //le joueur veux commencer par le niveau 1
                    break;
                case SDLK_KP2:
                    choix(ecran);       //Le joueur veut choisir par quel niveau il souhaite commencer
                    break;
                default: break;
 
 
            }
            break;
        default: break;
        }
        SDL_BlitSurface(menu1,NULL,ecran,&positionMenu);
        SDL_Flip(ecran);
    }
    SDL_FreeSurface(menu1);
    SDL_Quit();
    return EXIT_SUCCESS;
}

code de la fonction jeu (pas très joli, je vous l'accorde) :

Code:

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
void jouer(SDL_Surface *a, int niveau)
{
    SDL_Surface *mur=NULL, *mario_bas=NULL ,*mario_haut=NULL ,*mario_gauche=NULL ,*mario_droite=NULL ,*ecran=NULL, *sol=NULL, *objectif=NULL, *YOU_WIN, *echec, *YOU_LOSE, *herbes=NULL;
    SDL_Rect position, positionMario, sol_derriere_mario, pos, posEchec, position_depart;
    SDL_Event event;
 
    int x=0, y=6, machinX=0, machinY=0, win=0, Echec=0;
    int continuer = 1;
 
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR]={0};
    SDL_Init(SDL_INIT_VIDEO);
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("MazeRunner", NULL);
 
    mur=SDL_LoadBMP("mur.bmp");
    sol=SDL_LoadBMP("caisse.bmp");
    objectif=SDL_LoadBMP("objectif.bmp");
    herbes=SDL_LoadBMP("herbes.bmp");
    mario_bas=SDL_LoadBMP("mario_bas.bmp");
    mario_haut=SDL_LoadBMP("mario_haut.bmp");
    mario_droite=SDL_LoadBMP("mario_droite.bmp");
    mario_gauche=SDL_LoadBMP("mario_gauche.bmp");
    YOU_WIN=SDL_LoadBMP("you_win.bmp");
    echec=SDL_LoadBMP("echec.bmp");
    YOU_LOSE=SDL_LoadBMP("game_over.bmp");
 
 
    SDL_SetColorKey(mario_bas, SDL_SRCCOLORKEY, SDL_MapRGB(mario_bas->format, 0, 0, 255));
    SDL_SetColorKey(mario_haut, SDL_SRCCOLORKEY, SDL_MapRGB(mario_haut->format, 255, 255, 255));
    SDL_SetColorKey(mario_droite, SDL_SRCCOLORKEY, SDL_MapRGB(mario_droite->format, 255, 255, 255));
    SDL_SetColorKey(mario_gauche, SDL_SRCCOLORKEY, SDL_MapRGB(mario_gauche->format, 255, 255, 255));
    SDL_SetColorKey(objectif, SDL_SRCCOLORKEY, SDL_MapRGB(objectif->format, 255, 255, 255));
    SDL_SetColorKey(echec, SDL_SRCCOLORKEY, SDL_MapRGB(objectif->format, 255, 255, 255));
 
    position_depart.x=positionMario.x=0;                          //position de mario au depart
    position_depart.y=positionMario.y=TAILLE_BLOC*6;
    pos.x=0;                                                       // position de l image  YOU_WIN
    pos.y=0;
 
    //On veut afficher une premiere fois la carte pendant un temps donnee (ex: 1 seconde)
    FILE* fichier=NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR+1]={0};
    int i=0, j=0;
 
    if( niveau==1)  //si le joueur veut commencer par le niveau 1
    {
        fichier =fopen("niveau1.txt","r");
    }
    if(niveau==2)
    {
        fichier =fopen("niveau2.txt","r");
    }
    if(niveau==3)
    {
        fichier =fopen("niveau3.txt","r");
    }
    if(niveau==4)
    {
        fichier =fopen("niveau4.txt","r");
    }
    if(niveau==5)
    {
        fichier =fopen("niveau5.txt","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++)
                {
                    switch(ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
                    {
                        case'0':
                            carte[i][j]=VIDE;
                            break;
                        case'1':
                            carte[i][j]=MUR;
                            break;
                        case '2':
                            carte[i][j]=SOL;
                            break;
                        case '4':
                            carte[i][j]=ARRIVE;
                            break;
                    }
                }
            }
        fclose(fichier);
 
        //affichage du quadrillage a l ecran
        int k=0, m=0;
            for (k = 0 ; k < NB_BLOCS_LARGEUR ; k++)
            {
                for (m = 0 ; m < NB_BLOCS_HAUTEUR ; m++)
                {
                    position.x = k*TAILLE_BLOC;
                    position.y = m*TAILLE_BLOC;
 
                    switch(carte[k][m])
                    {
                    case VIDE:
                        SDL_BlitSurface(herbes,NULL,ecran,&position);
                        break;
                    case MUR:
                        SDL_BlitSurface(mur,NULL,ecran,&position);
                        break;
                    case SOL:
                        SDL_BlitSurface(sol,NULL,ecran,&position);
                        break;
                    case ARRIVE:
                        SDL_BlitSurface(sol,NULL,ecran,&position);
                        SDL_BlitSurface(objectif,NULL,ecran,&position);
                        break;
                    }
                }
            }
    SDL_Flip(ecran);
 
    Sleep(3000);                                                    // affichage du parcours pendant x milliseconde
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));  //on effeace l ecran
 
    SDL_BlitSurface(sol,NULL,ecran,&position_depart);
    SDL_BlitSurface(mario_droite,NULL,ecran,&position_depart);      // affichage du mario a sa position de depart au depart
    SDL_Flip(ecran);
 
    // a partir d ici le joueur ne voit plus que mario et doit se diriger vers la sortie a l aveugle
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
        case SDL_QUIT:
            continuer=0;
            break;
        case SDL_KEYDOWN:
            switch(event.key.keysym.sym)
            {
                case SDLK_UP://deplacement vers le haut
                    if(positionMario.y<0)                           // on verifie qu on est pas sur un bord haut
                        break;
                    if(carte[x][y-1]==MUR)                          //on verifie si la postion d apres n est pas un mur
                    {
                        Echec=Echec+1;
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        y=6;
                        x=0;
                        positionMario.x = position_depart.x;
                        positionMario.y = position_depart.y;
                        SDL_BlitSurface(mario_droite,NULL,ecran,&positionMario);
                        break;
                    }
                    y--;
                    positionMario.y = y * TAILLE_BLOC;
                    //Gros truc moche pour afficher le parcours derriere et en dessous de mario
                    machinX=positionMario.x;
                    machinY=positionMario.y;
                    sol_derriere_mario.x=machinX;
                    sol_derriere_mario.y=machinY+TAILLE_BLOC;
                    SDL_BlitSurface(sol,NULL,ecran,&sol_derriere_mario);             // affichage du parquet sur la position precedente de mario
                    SDL_BlitSurface(sol,NULL,ecran,&positionMario);                  // affichage du parquet en dessous de mario
                    SDL_BlitSurface(mario_haut,NULL,ecran,&positionMario);
                    if(carte[x][y]==ARRIVE) win=1;
                        break;
 
                case SDLK_DOWN://deplacement vers le bas
                    if(positionMario.y+1>LARGEUR_FENETRE-TAILLE_BLOC)
                        break;
                    if(carte[x][y+1]==MUR)
                    {
                        Echec=Echec+1;
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        y=6;
                        x=0;
                        positionMario.x = x * TAILLE_BLOC;
                        positionMario.y = y * TAILLE_BLOC;
                        SDL_BlitSurface(mario_haut,NULL,ecran,&positionMario);
                        break;
                    }
                    y++;
                    positionMario.y = y * TAILLE_BLOC;
                    machinX=positionMario.x;
                    machinY=positionMario.y;
                    sol_derriere_mario.x=machinX;
                    sol_derriere_mario.y=machinY-TAILLE_BLOC;
                    SDL_BlitSurface(sol,NULL,ecran,&sol_derriere_mario);
                    SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                    SDL_BlitSurface(mario_bas,NULL,ecran,&positionMario);
                    if(carte[x][y]==ARRIVE) win=1;
                        break;
 
                case SDLK_RIGHT://deplacement vers la droite
                    if(positionMario.x+1>LARGEUR_FENETRE-TAILLE_BLOC)
                        break;
                    if(carte[x+1][y]==MUR)
                    {
                        Echec=Echec+1;
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        y=6;
                        x=0;
                        positionMario.x = x * TAILLE_BLOC;
                        positionMario.y = y * TAILLE_BLOC;
                        SDL_BlitSurface(mario_bas,NULL,ecran,&positionMario);
                        break;
                    }
                    x++;
                    positionMario.x = x * TAILLE_BLOC;
                    machinX=positionMario.x;
                    machinY=positionMario.y;
                    sol_derriere_mario.x=machinX-TAILLE_BLOC;
                    sol_derriere_mario.y=machinY;
                    SDL_BlitSurface(sol,NULL,ecran,&sol_derriere_mario);
                    SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                    SDL_BlitSurface(mario_droite,NULL,ecran,&positionMario);
                    if(carte[x][y]==ARRIVE) win=1;
                        break;
 
                case SDLK_LEFT://deplacement vers la gauche
                    if(positionMario.x-1<0)
                        break;
                    if(carte[x-1][y]==MUR)
                    {
                        Echec=Echec+1;
                        y=6;
                        x=0;
                        SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                        positionMario.x = x * TAILLE_BLOC;
                        positionMario.y = y * TAILLE_BLOC;
                        SDL_BlitSurface(mario_bas,NULL,ecran,&positionMario);
                        break;
                    }
                    x--;
                    positionMario.x = x * TAILLE_BLOC;
                    machinX=positionMario.x;
                    machinY=positionMario.y;
                    sol_derriere_mario.x=machinX+TAILLE_BLOC;
                    sol_derriere_mario.y=machinY;
                    SDL_BlitSurface(sol,NULL,ecran,&sol_derriere_mario);
                    SDL_BlitSurface(sol,NULL,ecran,&positionMario);
                    SDL_BlitSurface(mario_gauche,NULL,ecran,&positionMario);
                    if(carte[x][y]==ARRIVE) win=1;
                        break;
 
                case SDLK_ESCAPE://sortie du programme
                    continuer = 0;
                        break;
                default: break;
            }
        }
        // affichage du nombre d echecs du joueur
        for(i=0; i<Echec;i++)
        {
            posEchec.x=0;
            posEchec.y=0;
            machinX=posEchec.x;
            machinY=posEchec.y;
            posEchec.x=machinX+i*TAILLE_BLOC;
            SDL_BlitSurface(echec,NULL,ecran,&posEchec);
        }
        if(win==1)// le joueur a atteint l objectif
        {
            if(niveau==5)                // le joueur en est a sa derniere partie
                {
                    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0)); // on efface l ecran
                    SDL_BlitSurface(YOU_WIN,NULL,ecran,&pos);
                    SDL_Flip(ecran);
                    Sleep(2000);
                    continuer=0;
                }
            if(niveau!=5)
            {
                SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0)); // on efface l ecran
                SDL_BlitSurface(YOU_WIN,NULL,ecran,&pos);
                SDL_Flip(ecran);
                Sleep(2000);        //on laisse l image affichze pendant 2 secondes
                niveau=niveau+1;
                jouer(ecran,niveau);        // on rappelle la fonction en chargement le niveau suivant
            }
 
        }
 
        if(Echec==3) // le joueur s est trompe trois fois
        {
            pos.x=(LARGEUR_FENETRE-300)/2;                          //determination de la position de l image "you lose" en fonction de la taille de la fenetre pour qu elle soit au milieu
            pos.y=(HAUTEUR_FENETRE-212)/2;
            SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0)); // on efface l ecran
            SDL_BlitSurface(YOU_LOSE,NULL,ecran,&pos);
            SDL_Flip(ecran);
            Sleep(2000);
            continuer=0;
        }
 
 
 
        SDL_Flip(ecran);
    }
    SDL_FreeSurface(mur);
    SDL_FreeSurface(sol);
    SDL_FreeSurface(herbes);
    SDL_FreeSurface(mario_droite);
    SDL_FreeSurface(mario_gauche);
    SDL_FreeSurface(mario_haut);
    SDL_FreeSurface(mario_bas);
    SDL_FreeSurface(YOU_WIN);
    SDL_FreeSurface(YOU_LOSE);
    SDL_FreeSurface(echec);
 
    SDL_Quit();
}

code de la fonction choix :

Code:

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
void choix(SDL_Surface *b)
{
    SDL_Surface *ecran = NULL, *menu2 = NULL;
    SDL_Rect positionMenu;
    SDL_Event event;
 
    int continuer = 1;
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("Choix du menu", NULL);
 
    menu2 =SDL_LoadBMP("menu2.bmp");
    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:
                        jouer(ecran,1);
                        break;
                    case SDLK_KP2:         //variable permettant a la bouce for de la fonction jeu de savoir quel niveau charger ensuite
                        jouer(ecran,2);
                        break;
                    case SDLK_KP3:
                        jouer(ecran,3);
                        break;
                    case SDLK_KP4:
                        jouer(ecran,4);
                        break;
                    case SDLK_KP5:
                        jouer(ecran,5);
                        break;
                    default: break;
 
 
                }
                break;
            default: break;
            }
            SDL_BlitSurface(menu2,NULL,ecran,&positionMenu);
            SDL_Flip(ecran);
        }
        SDL_FreeSurface(menu2);
        SDL_Quit();
}

Et j'aimerais également faire une fonction pour l'affichage. Mais je ne trouve pas de quel type doit être une fonction qui retourne un SDL (ou en tout cas qui doit retourner ce qu'il faut pour que une fois la fonction appelée, la carte s'affiche).

28/12/2019, 11h08
LittleWhite

À la fin de la fonction jouer, vous avez fait un SDL_Quit chose à faire, qu'à la fin du programme (et non à la fin des niveaux).
06/02/2020, 14h27
Niko44380

Merci beaucoup pour ton aide :) La présentation de notre programme devant les prof s'est plutôt bien passée.
Bonne continuation.