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

Collision avec des murs

SDL

Vue hybride

Discussions similaires

Partager

Partager