Discussion :

[talonneur56]

bonjour à tous,
je suis sur un projet de jeu pokémon en C/SDL. Je me suis basé sur un tuto trouvé sur Internet en y ajoutant du "mapping en 3 couches".

fmap.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
#include <string.h>//pour pouvoir utiliser memset et strcmp
#include "fmap.h"
 
 
 
 
 
Map* ChargerMap(const char* couche1, const char* couche2, const char* couche3, const char* image_corr, const char* tileset, const char* tileprop, int largeur_tile, int hauteur_tile, int hauteur_fenetre, int largeur_fenetre)
{
    int i,j;
    Map* res;
    SDL_Surface *schema1, *schema2, *schema3, *corr;
    Uint32 pix;
 
    res = malloc(sizeof(Map));
    res->LARGEUR_TILE = largeur_tile;
    res->HAUTEUR_TILE = hauteur_tile;
    res->tileset = LoadImage32(tileset,1);  // charge le tileset en VRAM pour meilleur vitesse de Blit.
    schema1 = LoadImage32(couche1, 0);
    schema2 = LoadImage32(couche2, 0);
    schema3 = LoadImage32(couche3, 0);
    corr = LoadImage32(image_corr,0);
 
    if (res->tileset == NULL || res->schema1 == NULL || res->schema2 == NULL || res->schema3 == NULL || corr == NULL)
    {
        fprintf(stderr, "error %s", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    res->nbtiles = (res->tileset->w / largeur_tile) * (res->tileset->h / hauteur_tile);// =>nb de tiles sur le tileset
    /* TODO (sylvain#1#): voir pour ajouter propriété pour gérer collision */
    res->props = ChargerProps(tileprop, res->nbtiles);//charge tableau avec les propriétés
    CalculerSDLRects(res->props, res->nbtiles, res->tileset->w / largeur_tile, largeur_tile, hauteur_tile);
    res->nbtiles_largeur_monde = schema1->w;
    res->nbtiles_hauteur_monde = schema1->h;
 
            //couche 1
    res->schema1 = malloc(schema1->w * sizeof(char*));
    for(i=0; i<schema1->w; i++)
    {
        res->schema1[i] = malloc(schema1->h * sizeof(char));
        for(j=0; j<schema1->h; j++)
        {
            pix = GetPixel32(schema1,i,j);
            res->schema1[i][j] = LocatePixInCorr(corr,pix);
        }
    }
            //couche 2
    res->schema2 = malloc(schema2->w * sizeof(char*));
    for(i=0; i<schema2->w; i++)
    {
        res->schema2[i] = malloc(schema2->h * sizeof(char));
        for(j=0; j<schema2->h; j++)
        {
            pix = GetPixel32(schema2,i,j);
            res->schema2[i][j] = LocatePixInCorr(corr,pix);
        }
    }
            //couche 3
    res->schema3 = malloc(schema3->w * sizeof(char*));
    for(i=0; i<schema3->w; i++)
    {
        res->schema3[i] = malloc(schema3->h * sizeof(char));
        for(j=0; j<schema3->h; j++)
        {
            pix = GetPixel32(schema3,i,j);
            res->schema3[i][j] = LocatePixInCorr(corr,pix);
        }
    }
 
 
    SDL_FreeSurface(schema1);
    SDL_FreeSurface(schema2);
    SDL_FreeSurface(schema3);
    SDL_FreeSurface(corr);
    res->largeur_fenetre = largeur_fenetre;
    res->hauteur_fenetre = hauteur_fenetre;
    res->xscroll = 0;
    res->yscroll = 0;
    return res;
}
 
 
 
TileProp* ChargerProps(const char* tileprop, int nombre_props)
{
    char buf[500];
    FILE* F;
    int i;
    int useless;
    TileProp* res = calloc(nombre_props,sizeof(TileProp)); // alloue et met tout a 0.
    F = fopen(tileprop,"r");
    if (F==NULL)
    {
        printf("fichier %s introuvable !!\n",tileprop);
        exit(-1);
    }
    for(i=0; i<nombre_props; i++)
    {
        fscanf(F,"%d %s",&useless,buf);//on met le n° de tile dans useless (qu'on utilise pas) et la "propriété" dans buf
 
        if (strcmp(buf,"mur")==0)//on compare la propriété lue avec mur, si c'est la même on renvoie 0
            res[i].mur = 1;
 
        if(strcmp(buf, "vide")==0)
            res[i].vide = 1;
    }
    fclose(F);
    return res;
}
 
 
 
char LocatePixInCorr(SDL_Surface* corr, Uint32 pix)
{
    int i,j;
    for(j=0; j<corr->h; j++)
        for(i=0; i<corr->w; i++)
            if (GetPixel32(corr,i,j)==pix)
                return (char)(j*corr->w + i);
    return 0;
}
 
 
 
void CalculerSDLRects(TileProp* tabprops, int nombre_props, int nombre_tiles_largeur, int largeur_tile, int hauteur_tile)
{
    int i;
    for(i=0; i<nombre_props; i++)
    {
        tabprops[i].R.w = largeur_tile;
        tabprops[i].R.h = hauteur_tile;
        tabprops[i].R.x = largeur_tile*(i%nombre_tiles_largeur);
        tabprops[i].R.y = hauteur_tile*(i/nombre_tiles_largeur);
    }
}
 
 
 
Perso* ChargerPerso(const char* sprite, int x, int y, int w, int h)
{
    Perso* p;
 
    p = malloc(sizeof(Perso));
    p->sprite = SDL_LoadBMP(sprite);
    if (p->sprite == NULL)
    {
        fprintf(stderr, "error %s", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    p->R.x = x;
    p->R.y = y;
    p->R.w = w;
    p->R.h = h;
 
    return p;
}
 
 
 
Perso* Deplace(Input* in, Map* carte, Perso* perso, int LARGEUR_TILE, int HAUTEUR_TILE)//deplace le perso
{
    switch(in->key[SDLK_LAST])
    {
        case SDLK_UP:
            if (CollisionDecor(carte, perso, 0) == 0);//pas de collision
            {
                perso->R.y+=HAUTEUR_TILE;
            }
            break;
 
        case SDLK_DOWN:
            if (CollisionDecor(carte, perso, 1) == 0);//pas de collision
            {
                perso->R.y-=HAUTEUR_TILE;
            }
            break;
 
        case SDLK_LEFT:
            if (CollisionDecor(carte, perso, 2) == 0);//pas de collision
            {
                perso->R.x-=LARGEUR_TILE;
            }
            break;
 
        case SDLK_RIGHT:
            if (CollisionDecor(carte, perso, 3) == 0);//pas de collision
            {
                perso->R.x+=LARGEUR_TILE;
            }
            break;
 
        default:
            break;
    }
    return perso;
}
 
 
 
int CollisionDecor(Map* carte, Perso* perso, char dir)
{
    int xmin, xmax, ymin, ymax, i, j, indicetile;
 
    xmin = perso->R.x / carte->LARGEUR_TILE;
    ymin = perso->R.y / carte->HAUTEUR_TILE;
    xmax = (perso->R.x + perso->R.w -1) / carte->LARGEUR_TILE;
    ymax = (perso->R.y + perso->R.h -1) / carte->HAUTEUR_TILE;
 
    if (xmin<0 || ymin<0 || xmax>=carte->nbtiles_largeur_monde || ymax>=carte->nbtiles_hauteur_monde)//si on cherche a sortir du monde on renvoie "collision"
        return 1;// collision
 
 
    for(i=xmin; i<=xmax; i++) //la double boucle parcours les tiles sur lequel se situe le perso
    {
        for(j=ymin; j<=ymax; j++)
        {
            indicetile = carte->schema2[i][j];
            if (carte->props[indicetile].mur)
                return 1;//collision
        }
    }
    return 0;//pas de collision
}
 
 
 
int FocusScrollCenter(Map* carte, Perso* perso)
{
    carte->xscroll = perso->R.x + perso->R.w/2 - carte->largeur_fenetre/2;
    carte->yscroll = perso->R.y + perso->R.h/2 - carte->hauteur_fenetre/2;
    ClampScroll(carte);
    return 0;
}
 
 
 
void ClampScroll(Map* m)
{
    if (m->xscroll<0)
        m->xscroll=0;
 
    if (m->yscroll<0)
        m->yscroll=0;
 
    if (m->xscroll>m->nbtiles_largeur_monde*m->LARGEUR_TILE-m->largeur_fenetre-1)
        m->xscroll=m->nbtiles_largeur_monde*m->LARGEUR_TILE-m->largeur_fenetre-1;
 
    if (m->yscroll>m->nbtiles_hauteur_monde*m->HAUTEUR_TILE-m->hauteur_fenetre-1)
        m->yscroll=m->nbtiles_hauteur_monde*m->HAUTEUR_TILE-m->hauteur_fenetre-1;
}
 
 
 
int AfficherMap(Map* m, SDL_Surface* screen, Perso* perso)
{
    int i,j;
    SDL_Rect Rect_dest;
    int numero_tile;
    int minx,maxx,miny,maxy;
    minx = m->xscroll / m->LARGEUR_TILE;
    miny = m->yscroll / m->HAUTEUR_TILE;
    maxx = (m->xscroll + m->largeur_fenetre)/m->LARGEUR_TILE;
    maxy = (m->yscroll + m->hauteur_fenetre)/m->HAUTEUR_TILE;
    /*calcule position fenetre de scrolling sur map*/
 
 
 
 
            //1ère couche
    for(i=minx; i<maxx; i++) //on parle en tiles
    {
        for(j=miny; j<maxy; j++)
        {
            Rect_dest.x = i*m->LARGEUR_TILE - m->xscroll;
            Rect_dest.y = j*m->HAUTEUR_TILE - m->yscroll;
            numero_tile = m->schema1[i][j];
            SDL_BlitSurface(m->tileset, &(m->props[numero_tile].R), screen, &Rect_dest);
        }
    }
 
 
            //2ème couche
     for(i=minx; i<maxx; i++) //on parle en tiles
    {
        for(j=miny; j<maxy; j++)
        {
            Rect_dest.x = i*m->LARGEUR_TILE - m->xscroll;
            Rect_dest.y = j*m->HAUTEUR_TILE - m->yscroll;
            numero_tile = m->schema2[i][j];
            SDL_BlitSurface(m->tileset, &(m->props[numero_tile].R), screen, &Rect_dest);
        }
    }
 
            //personnage
    AfficherPerso(perso, screen, m->xscroll, m->yscroll);
 
 
            //3ème couche
     for(i=minx; i<=maxx; i++) //on parle en tiles
    {
        for(j=miny; j<=maxy; j++)
        {
            Rect_dest.x = i*m->LARGEUR_TILE - m->xscroll;
            Rect_dest.y = j*m->HAUTEUR_TILE - m->yscroll;
            numero_tile = m->schema3[i][j];
 
            SDL_BlitSurface(m->tileset, &(m->props[numero_tile].R), screen, &Rect_dest);
        }
    }
 
    return 0;
}
 
 
 
void AfficherPerso(Perso* perso, SDL_Surface* screen, int xscroll, int yscroll)
 
{
	//Perso positionsurecran = *perso;
	perso->R.x -= xscroll;
	perso->R.y -= yscroll;
    SDL_SetColorKey(perso->sprite, SDL_SRCCOLORKEY, SDL_MapRGB(perso->sprite->format, 238, 104, 189));//fond transparent
    SDL_BlitSurface(perso->sprite, NULL, screen, &perso->R);
 
	//SDL_FillRect(screen, &positionsurecran, 0x00FF00);
}
 
 
 
int LibererMap(Map* m, Perso* perso)
{
    int i;
    for(i=0; i<m->nbtiles_hauteur_monde; i++)
    {
 
        free(m->schema1[i]);
        free(m->schema2[i]);
        free(m->schema3[i]);
    }
    free(m->schema1);
    free(m->schema2);
    free(m->schema3);
    free(m->props);
    free(m);
    free(perso);
    return 0;
}

fmap.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
#ifndef _FMAP_H
#define _FMAP_H
 
#include "utils.h"
 
typedef struct//TileProp
{
	SDL_Rect R;
	char mur;
	char vide;
	// tout ce que vous voulez...
} TileProp;
 
typedef struct//Map
{
	int LARGEUR_TILE,HAUTEUR_TILE;
	int nbtiles;
	TileProp* props;
	SDL_Surface* tileset;
	unsigned char **schema1, **schema2, **schema3;
	int nbtiles_largeur_monde,nbtiles_hauteur_monde;
	int xscroll,yscroll;
	int largeur_fenetre,hauteur_fenetre;
} Map;
 
 
 
Map* ChargerMap(const char* couche1, const char* couche2, const char* couche3, const char* image_corr, const char* tileset, const char* tileprop, int largeur_tile, int hauteur_tile, int hauteur_fenetre, int largeur_fenetre);
 
 
 
TileProp* ChargerProps(const char* tileprop, int nombre_props);
 
 
 
char LocatePixInCorr(SDL_Surface* corr, Uint32 pix);
 
 
 
void CalculerSDLRects(TileProp* tabprops, int nombre_props, int nombre_tiles_largeur, int largeur_tile, int hauteur_tile);
 
 
 
Perso* ChargerPerso(const char* sprite, int x, int y, int w, int h);
 
 
 
Perso* Deplace(Input* in, Map* carte, Perso* perso, int LARGEUR_TILE, int HAUTEUR_TILE);//deplace le perso
 
 
 
int CollisionDecor(Map* carte, Perso* perso, char dir);
 
 
 
int FocusScrollCenter(Map* carte, Perso* perso);
 
 
 
void ClampScroll(Map* m);
 
 
 
int AfficherMap(Map* m, SDL_Surface* screen, Perso* perso);
 
 
 
void AfficherPerso(Perso* perso, SDL_Surface* screen, int xscroll, int yscroll);
 
 
 
int LibererMap(Map* m, Perso* perso);
 
 
 
#endif

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include "fmap.h"
 
 
 
 
 
 
 
int main(int argc,char** argv)
{
	SDL_Surface* screen;
	Map* carte;
	Perso* perso;
	Input in;
	int LARGEUR_TILE, HAUTEUR_TILE;
	LARGEUR_TILE = 16;
	HAUTEUR_TILE = 16;
	memset(&in, 0, sizeof(in));
	SDL_Init(SDL_INIT_VIDEO);
 
	carte = ChargerMap("1 schema bourg en vol.bmp","2 schema bourg en vol.bmp","3 schema bourg en vol.bmp","corr bourg en vol.bmp", "tileset bourg en vol.bmp","tileprop1.txt", LARGEUR_TILE, HAUTEUR_TILE, 800, 600);
 
	screen = SDL_SetVideoMode(carte->largeur_fenetre, carte->hauteur_fenetre, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
 
	perso = ChargerPerso("perso.bmp", 128, 224, 16, 21);
	while(!in.key[SDLK_ESCAPE]&& !in.quit)
	{
		UpdateEvents(&in);
		Deplace(&in, carte, perso, LARGEUR_TILE, HAUTEUR_TILE);//deplace si possible le perso
		FocusScrollCenter(carte, perso);//calcule la position de fenetre de scrolling pour que le perso soit toujours au centre
		AfficherMap(carte, screen, perso);//affiche la map et le perso
		SDL_Flip(screen);
	}
	LibererMap(carte, perso);
	SDL_Quit();
	return EXIT_SUCCESS;
}

utils.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include "utils.h"
 
void UpdateEvents(Input* in)
{
	SDL_Event event;
	while(SDL_PollEvent(&event))
	{
		switch (event.type)
		{
			case SDL_KEYDOWN:
				in->key[event.key.keysym.sym]=1;
				break;
 
			case SDL_KEYUP:
				in->key[event.key.keysym.sym]=0;
				break;
 
			case SDL_QUIT:
				in->quit = 1;
				break;
 
			default:
				break;
		}
	}
}
 
 
 
SDL_Surface* LoadImage32(const char* fichier_image,int vram)
{
	SDL_Surface* image_result;
	SDL_Surface* image_ram = SDL_LoadBMP(fichier_image);	// charge l'image dans image_ram en RAM
	if (image_ram==NULL)
	{
		printf("Image %s introuvable !! \n",fichier_image);
		SDL_Quit();
		exit(-1);
	}
	image_result = NULL;
	if (vram)
		image_result=SDL_CreateRGBSurface(SDL_HWSURFACE, image_ram->w, image_ram->h, 32, 0, 0, 0, 0);  // cree une image en VRAM
	if (image_result==NULL)
		vram = 0;
	if (!vram)
		image_result=SDL_CreateRGBSurface(SDL_SWSURFACE, image_ram->w, image_ram->h, 32, 0, 0, 0, 0);  // cree une image en RAM
	SDL_BlitSurface(image_ram,NULL,image_result,NULL);	// copie l'image image_ram de moins de 32 bits vers image_result qui fait 32 bits
	SDL_FreeSurface(image_ram);      // supprime la surface image_ram : inutile maintenant --> libere la mémoire
	return image_result;
}
 
 
 
Uint32 GetPixel32(SDL_Surface* image,int i,int j)
{
	if (i<0 || i>image->w-1 || j<0 || j>image->h-1)
		return 0;
	return ((Uint32*)(image->pixels))[j*(image->pitch/4)+i];   // lecture directe des pixels
}

utils.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#ifndef _UTILS_H
#define _UTILS_H
 
#include <SDL.h>
 
 
 
typedef struct
{
	int key[SDLK_LAST];
	char quit;
} Input;
 
 
typedef struct
{
    SDL_Rect R;
    SDL_Surface* sprite;
} Perso;
 
 
void UpdateEvents(Input* in);
 
SDL_Surface* LoadImage32(const char* fichier_image,int vram);
 
Uint32 GetPixel32(SDL_Surface* image,int i,int j);
 
#endif

Mais le problème, c'est que venu le moment de compilé j'ai une erreur de segmentation que je n'arrive pas à trouver...

Cela fait déjà plusieurs jours que je tente de la trouver en relisant le code car je ne sais pas utiliser le débuggeur (gdb).

Si quelqu'un avait l'infini gentillesse, bonté ou générosité de m'aider en débuggant mon code et me dire comment il s'y est pris ça serait sympa car là je commence un peu à désespérer...

[Sve@r]

Mais le problème, c'est que venu le moment de compilé j'ai une erreur de segmentation que je n'arrive pas à trouver...

Un segfault à la compilation ? Ca c'est du jamais vu !!! T'as essayé de changer de compilateur ???

Cela fait déjà plusieurs jours que je tente de la trouver en relisant le code

Parce que tu crois que l'erreur va te faire des signes ?

Si quelqu'un avait l'infini gentillesse, bonté ou générosité de m'aider en débuggant mon code et me dire comment il s'y est pris ça serait sympa car là je commence un peu à désespérer...

Ma poupougne, tu vas faire un peu comme ont fait nos ancêtres les gaulois: tu vas
1) te sortir les doigts
2) rajouter du printf() un peu partout
3) utiliser ta tête en réfléchissant et en affinant le positionnement des printf() au fur et à mesure de tes tests jusqu'à trouver la ligne qui chie. Quand tu l'auras trouvée, tu te demanderas pourquoi elle chie (probablement un pointeur qui pointe là où il ne faut pas)...

[Obsidian]

2) rajouter du printf() un peu partout
3) utiliser ta tête en réfléchissant et en affinant le positionnement des printf() au fur et à mesure de tes tests jusqu'à trouver la ligne qui chie. Quand tu l'auras trouvée, tu te demanderas pourquoi elle chie (probablement un pointeur qui pointe là où il ne faut pas)...

Hmm. Pas d'accord (enfin pas tout-à-fait).

Le debugging au printf, même si tous les programmeurs du monde font ça, est quand même une habitude que l'on essaie de faire perdre au profit des vrais outils de déboguage. si Talonneur56 a la volonté de les utiliser directement, il faut en profiter.

Cela fait déjà plusieurs jours que je tente de la trouver en relisant le code car je ne sais pas utiliser le débuggeur (gdb). Si quelqu'un avait l'infini gentillesse, bonté ou générosité de m'aider en débuggant mon code et me dire comment il s'y est pris ça serait sympa car là je commence un peu à désespérer...

Il faut compiler ton programme avec l'option « -g » pour inclure les symboles de déboguage (à dire vrai, pratiquement tout ton code source sera intégré à l'exécutable dans ce mode). Ensuite, tu lances « gdb ./tonprogramme ».

De là, tu es dans le débogueur mais ton programme lui-même n'est pas encore lancé. Ça se fait avec « r (ou run) argument1 argument2 … ». Les arguments sont les mêmes que ceux que tu passes éventuellement sur la ligne de commande.

Ton programme va planter. Tape « bt (ou backtrace) » pour obtenir la pile des appels de fonctions en cours (une fonction qui appelle une fonction, qui elle même appelle une troisième fonction, et ainsi de suite). Tu obtiens le détail des fonctions appelées avec, lorsque c'est possible, le nom du fichier et la ligne concernée.

Tape « l (ou list) » suivi d'un numéro de ligne, ou d'un nom de fichier et d'un numéro de ligne séparés par un deux-points « nomdefichier:numerodeligne » pour avoir le détail du code source autour de cet endroit.

Autres commandes :

— « s » pour Step Into : avance d'une seule instruction, et entre dans le code d'une fonction plutôt que simplement passer à la ligne suivante ;
— « n » pour Next : lance l'exécution jusqu'à la ligne suivante ;
— « b » pour BreakPoint : pose un break point à l'endroit voulu. Le programme s'interrompra automatiquement à cet endroit, en rendant temporairement la main au débogueur ;
— « d » pour Delete : pour supprimer des breakpoints ;
— « watch » pour la valeur d'une expression donnée (par exemple un nom de variable). S'interrompt dès que la valeur change ;
— « c » pour Continue : poursuivre une exécution qui a démarré et s'est interrompue suite à un des artifices présentés ci-dessus ;

Et enfin :

« help » qui te permet d'avoir en ligne le détail de chaque commande, section par section.

Utilise aussi valgrind, très puissant pour tout ce qui touche à l'initialisation de la mémoire (cause directe des segfaults).

[talonneur56]

valgrind est réservé pour les système unix je crois non?

merci Obsidian de ton aide, mais c'est vraiment "le bazar" j'ai des "infos" dans la fenetre watches et call stack j'essaie un peu à taton mais ça n'avance pas...

[Obsidian]

Si tu as des « fenêtres », et qu'en plus tu ne travailles pas sous Unix, alors tu n'utilises probablement pas gdb (à part via ddd).

Que dit la call stack ?

[talonneur56]

ce n'est pas réellement des fenetre c'est des petits cadres qui apparaissent quand on clique sur l'icone "debugging windows" et qu'on clique sur watches ou call stack

call stack:

#0 004021C8 AfficherMap(m=0xa143b0, screen=0xa13810, perso=0x1ff9fa8) (C:\Users\sylvain.ORDI-FIXE\Documents\projets\SDL\Projet personel\pokémon\test\schema pixel avec scrolling auto et perso\fmap.c:281)
#1 0040146D SDL_main(argc=1, argv=0xa11590) (C:\Users\sylvain.ORDI-FIXE\Documents\projets\SDL\Projet personel\pokémon\test\schema pixel avec scrolling auto et perso\main.c:48)
#2 0040309B console_main(argc=1, argv=0xa11590) (./src/main/win32/SDL_win32_main.c:315)
#3 00403158 WinMain(hInst=0x400000, hPrev=0x0, szCmdLine=0x733a22 "", sw=10) (./src/main/win32/SDL_win32_main.c:398)
#4 00000000 0x00402a26 in main() (??: ??)

un petit triangle jaune s'est mis à cette ligne:

Code :

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

numero_tile = m->schema1[i][j];

ça veut dire qu'il y a des nombres beaucoup trop grand dans mon tableau à 2 dimension(dans watches numero_tile vaut 4202467), mais ce tableau se fait remplir dans ChargerMap donc c'est forcement la-bas que ça bug mais quand je met un breakpoint le debuggage ne s'y arrete pas...

[Sve@r]

un petit triangle jaune s'est mis à cette ligne:

Code :

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

numero_tile = m->schema1[i][j];

ça veut dire qu'il y a des nombres beaucoup trop grand dans mon tableau à 2 dimension(dans watches numero_tile vaut 4202467), mais ce tableau se fait remplir dans ChargerMap donc c'est forcement la-bas que ça bug mais quand je met un breakpoint le debuggage ne s'y arrete pas...

Ben déjà schema1[x][y] est un unsigned char donc il ne peut pas dépasser 255. Et numero_tile est un int donc (sous-entendu que chez-toi les int soient des short), ne peut pas dépasser 32767...

A ce propos, j'ai remarqué 3 trucs

Code c :

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
typedef struct//Map
{
	int LARGEUR_TILE,HAUTEUR_TILE;
	int nbtiles;
	TileProp* props;
	SDL_Surface* tileset;
	unsigned char **schema1, **schema2, **schema3;
	int nbtiles_largeur_monde,nbtiles_hauteur_monde;
	int xscroll,yscroll;
	int largeur_fenetre,hauteur_fenetre;
} Map;
 
#include <string.h>//pour pouvoir utiliser memset et strcmp
#include "fmap.h"
 
 
Map* ChargerMap(const char* couche1, const char* couche2, const char* couche3, const char* image_corr, const char* tileset, const char* tileprop, int largeur_tile, int hauteur_tile, int hauteur_fenetre, int largeur_fenetre)
{
   ... 
        //couche 1
    res->schema1 = malloc(schema1->w * sizeof(char*));
    for(i=0; i<schema1->w; i++)
    {
        res->schema1[i] = malloc(schema1->h * sizeof(char));
        for(j=0; j<schema1->h; j++)
        {
            pix = GetPixel32(schema1,i,j);
            res->schema1[i][j] = LocatePixInCorr(corr,pix);
        }
    }
            //couche 2
    res->schema2 = malloc(schema2->w * sizeof(char*));
    for(i=0; i<schema2->w; i++)
    {
        res->schema2[i] = malloc(schema2->h * sizeof(char));
        for(j=0; j<schema2->h; j++)
        {
            pix = GetPixel32(schema2,i,j);
            res->schema2[i][j] = LocatePixInCorr(corr,pix);
        }
    }
            //couche 3
    res->schema3 = malloc(schema3->w * sizeof(char*));
    for(i=0; i<schema3->w; i++)
    {
        res->schema3[i] = malloc(schema3->h * sizeof(char));
        for(j=0; j<schema3->h; j++)
        {
            pix = GetPixel32(schema3,i,j);
            res->schema3[i][j] = LocatePixInCorr(corr,pix);
        }
    }
    ...
}
 
char LocatePixInCorr(SDL_Surface* corr, Uint32 pix)
{
    int i,j;
    for(j=0; j<corr->h; j++)
        for(i=0; i<corr->w; i++)
            if (GetPixel32(corr,i,j)==pix)
                return (char)(j*corr->w + i);
    return 0;
}

C'est sûrement pas la cause du segfault mais bon, s'il y a déjà des incohérences ici, il y en a sûrement ailleurs...

[talonneur56]

dans watches il y est mis:"numero_tile = 4202467" et oui en y réfléchissant sa cloche a moins que j’interprète mal...

EDIT:

a propos des 3 petits truc que tu as repéré, c'est vrai que je n'avais pas fais gaffe, mais bon je ne sais pas si c'est dérangeant pour le moment mais effectivement par la suite quand j'aurais des numero de tile supérieur a un char sa sera a modifié

[Obsidian]

ça veut dire qu'il y a des nombres beaucoup trop grand dans mon tableau à 2 dimension(dans watches numero_tile vaut 4202467), mais ce tableau se fait remplir dans ChargerMap donc c'est forcement la-bas que ça bug mais quand je met un breakpoint le debuggage ne s'y arrete pas...

Non, c'est probablement un buffer overflow ordinaire, dû au fait que ce sont les valeurs de tes indices i et j qui sont incorrectes. Ce sont donc elles qu'il faut vérifier.

Lorsque tu déclares un tableau en langage C, le compilateur alloue simplement une zone de mémoire consécutive dans la pile. Et quand tu l'exploites, il ajoute simplement la valeur de tes indices à l'adresse de départ de ton tableau sans autre forme de contrôle. C'est dû au fait que le langage C a vocation à produire du code le plus proche de la machine possible, en réduisant au minimum les recours à des ressources ou des bibliothèques sous-jacentes. En gros, l'idée est de pouvoir presque toujours faire en C ce que tu pourrais faire en assembleur.

Donc si i et/ou j ont des valeurs qui dépassent les limites, tu vas aller lire des choses à côté de ton tableau et qui n'ont rien à voir avec ce qu'il y a dedans. Si tu lis trop loin (comprendre : en dehors de l'espace alloué à ton processus), tu finis en segfault car c'est le micro-processeur lui-même qui t'empêchera de le faire. Mais si tu restes dans les limites, tu peux écraser de la sorte des variables déclarées à côté de ton tableau sans t'en rendre compte, en provoquant des bugs beaucoup plus loin. Et là, ça devient chiant à dépanner.

C'est un problème extrêmement courant, et ça fait partie des premières embûches rencontrées par tous les débutants. Cela dit, avant le mode protégé, un buffer overflow, si courant soit-il, pouvait aller écraser toute la mémoire et faire planter l'ordinateur entier.

Accessoirement, « 4294967295 » (nombre qui ressemble beaucoup à celui qui tu nous cites), ça fait FFFFFFFF en hexadécimal, soit la valeur maximum que l'on peut coder avec un entier non signé sur 32 bits.

Enfin, n'oublie pas que les indices d'un tableau commencent à partir de zéro. Donc, si tu as déclaré un tableau « int tab[10] », par exemple, les cases valides ne vont que de tab[0] à tab[9].

[Sve@r]

a propos des 3 petits truc que tu as repéré, c'est vrai que je n'avais pas fais gaffe, mais bon je ne sais pas si c'est dérangeant pour le moment

Ben mettre un char (pourvu qu'il reste compris entre 0 et 127) dans un unsigned char (acceptant des valeurs allant de 0 à 255) c'est pas dérangeant en soi. C'est l'inverse qui pourrait l'être. Parce que si tu places 128 dans un signed char, alors il sera vu comme valant -127.
Et bien entendu, tout nombre négatif placé dans un unsigned est alors converti en positif associé au codage binaire correspondant...

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
 
int AfficherMap(Map* m, SDL_Surface* screen, Perso* perso)
{
    int i,j;
    SDL_Rect Rect_dest;
    int numero_tile;
    int minx,maxx,miny,maxy;
    minx = m->xscroll / m->LARGEUR_TILE;
    miny = m->yscroll / m->HAUTEUR_TILE;
    maxx = (m->xscroll + m->largeur_fenetre)/m->LARGEUR_TILE;
    maxy = (m->yscroll + m->hauteur_fenetre)/m->HAUTEUR_TILE;
    /*calcule position fenetre de scrolling sur map*/
 
 
 
 
            //1ère couche
    for(i=minx; i<maxx; i++) //on parle en tiles
    {
        for(j=miny; j<maxy; j++)
        {
            Rect_dest.x = i*m->LARGEUR_TILE - m->xscroll;
            Rect_dest.y = j*m->HAUTEUR_TILE - m->yscroll;
            numero_tile = m->schema1[i][j];
            SDL_BlitSurface(m->tileset, &(m->props[numero_tile].R), screen, &Rect_dest);
        }
    }

Non, c'est probablement un buffer overflow ordinaire, dû au fait que ce sont les valeurs de tes indices i et j qui sont incorrectes. Ce sont donc elles qu'il faut vérifier
....
Enfin, n'oublie pas que les indices d'un tableau commencent à partir de zéro. Donc, si tu as déclaré un tableau « int tab[10] », par exemple, les cases valides ne vont que de tab[0] à tab[9].

Surtout qu'en regardant bien, i et j varient de minx à maxx. Ce qui n'est autorisé qu'à la condition que minx et maxx soient inférieurs à la taille du tableau...

[talonneur56]

ok mais la fonction ClampScroll empêche cela de se produire non?

[Sve@r]

ok mais la fonction ClampScroll empêche cela de se produire non?

En fait faut bien que tu comprennes qu'on n'a pas tout lu ton code en détail. Ni même tenté de l'exécuter (en plus il nous manque sûrement des librairies pour ça).
On te donne juste des pistes qui nous semblent cohérentes à propos des indices des tableaux (parce que c'est souvent la cause des segfault) mais on ne peut pas tout examiner...

[talonneur56]

bon voila je me suis remis sérieusement sur mon projet et j'y est apporté quelques modifications et le probleme a été résolue

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
 
Map* ChargerMap(const char* tileset, const char* image_schema1, const char* image_schema2, const char* image_schema3, const char* image_corr, const char* tileprop, int TAILLE_TILE, int largeur_fenetre, int hauteur_fenetre)
int i,j;
    Map* res;
    SDL_Surface *IMGschema1, *IMGschema2, *IMGschema3, *corr;
    Uint32 pix;
 
    res = malloc(sizeof(Map));
    res->taille_tile = TAILLE_TILE;
    res->tileset = LoadImage32(tileset,1);  // charge le tileset en VRAM pour meilleur vitesse de Blit.
 
    IMGschema1 = LoadImage32(image_schema1,0);
    IMGschema2 = LoadImage32(image_schema2,0);
    IMGschema3 = LoadImage32(image_schema3,0);
    corr = LoadImage32(image_corr,0);
 
    if(IMGschema1 == NULL || IMGschema2 == NULL || IMGschema3 == NULL || corr == NULL)
    {
        fprintf(stderr, "error :%s", SDL_GetError);
        exit(EXIT_FAILURE);
    }
 
    res->nbtiles = (res->tileset->w / taille_tile) * (res->tileset->h / taille_tile);
    res->props = ChargerProps(tileprop,res->nbtiles);
    res->nbtiles_largeur_monde = IMGschema1->w;
    res->nbtiles_hauteur_monde = IMGschema1->h;
    CalculerSDLRects(res->props, res->nbtiles, res->tileset->w / nbtiles_largeur_monde, TAILLE_TILE);
    res->Schema = malloc( 3*sizeof(char*)); // tableau de pointeurs sur pointeurs
    if(res->Schema == NULL)
    {
        fprintf(stderr, "error initialisation tableau de chiffres");
        exit(EXIT_FAILURE);
    }
 
 
    res->Schema[0] = malloc(IMGschema1->w * sizeof(char**)); //2ème dimension comme les **
    for(i=0; i<IMGschema1->w; i++)
    {
        res->Schema[0][i] = malloc(IMGschema1->h * sizeof(char***)); //3ème dimension comme les ***
        for(j=0; j<IMGschema1->h; j++)
        {
            pix = GetPixel32(IMGschema1,i,j);
            res->Schema[0][i][j] = LocatePixInCorr(corr,pix);
        }
    }
 
 
 
    res->Schema[1] = malloc(IMGschema2->w * sizeof(char**));
    for(i=0; i<IMGschema2->w; i++)
    {
        res->Schema[1][i] = malloc(IMGschema2->h * sizeof(char***));
        for(j=0; j<IMGschema2->h; j++)
        {
            pix = GetPixel32(IMGschema2,i,j);
            res->Schema[1][i][j] = LocatePixInCorr(corr,pix);
        }
    }
 
 
 
 
    res->Schema[2] = malloc(IMGschema3->w * sizeof(char**));
    for(i=0; i<IMGschema3->w; i++)
    {
        res->Schema[2][i] = malloc(IMGschema3->h * sizeof(char***));
        for(j=0; j<IMGschema3->h; j++)
        {
            pix = GetPixel32(IMGschema3,i,j);
            res->Schema[2][i][j] = LocatePixInCorr(corr,pix);
        }
    }
 
 
 
    SDL_FreeSurface(IMGschema1);
    SDL_FreeSurface(IMGschema2);
    SDL_FreeSurface(IMGschema3);
    SDL_FreeSurface(corr);
    res->largeur_fenetre = largeur_fenetre;
    res->hauteur_fenetre = hauteur_fenetre;
 
    return res;
}

merci à vous pour votre aide