Collision avec des murs

**Niko44380** · 07/12/2019, 21h07

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 :

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
 
#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!

**LittleWhite** · 08/12/2019, 11h05

Bonjour,

Envoyé par Niko44380

la fenêtre du jeu se ferme...

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

(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 :

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

mur=SDL_LoadBMP("mur.BMP");

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

Code :

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

SDL_EnableKeyRepeat(150, 150);

et

Code :

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

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 :

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

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 :

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

positionMario.y = y * TAILLE_BLOC;

Peut être il faudrait utiliser les variables x et y plutôt

(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 !

**Captcha76** · 08/12/2019, 17h25

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 :

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
#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

**LittleWhite** · 08/12/2019, 18h50

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

.

**Captcha76** · 08/12/2019, 20h57

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 :

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

 enum {VIDE, MUR, SOL, MARIO};

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

**LittleWhite** · 08/12/2019, 21h05

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 :

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

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 :

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

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 :

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

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é.

**Niko44380** · 11/12/2019, 11h43

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

Code :

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

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

On a remplacé par

Code :

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

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

et ça marche impec! ! !

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 :

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
  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 :

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

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 :

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
 
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;
}

**LittleWhite** · 11/12/2019, 20h00

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

.

**Niko44380** · 12/12/2019, 20h36

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 :

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
#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 :

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
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 :

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
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).