soucis dans tile mapping

**talonneur56** · 22/12/2011, 22h47

bonjour à tous et à toutes,

dans mon projet, je souhaite mettre en place un tile mapping (avec scrolling) . Le problème est le suivant: quand j'ajoute le scrolling à mon code la propriété "mur" des tiles concerné est toujours égal à 0, j'ai toujours une bande blanche en bas de ma fenêtre et si je ne met pas de printf la fonction AfficherPerso et perso ne se déplace pas.

Pouvez-vous m'aider à corriger ces erreurs SVP?

tile4.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
#include "fmap4.h"
 
 
 
 
int main(int argc,char** argv)
{
	SDL_Surface *screen;
	Map* carte;
	Input in;
	Joueur P;
 
	unsigned int elapsed, lasttime;
 
 
 
	memset(&in, 0, sizeof(in));
 
	if (SDL_Init(SDL_INIT_VIDEO) == -1)
	{
	    printf("erreur chargement SDL_INIT: %s", SDL_GetError());
	    exit(EXIT_FAILURE);
	}
 
 
	carte = ChargerMap("tileset bourg en vol.bmp", "1 schema bourg en vol.bmp",  "2 schema bourg en vol.bmp", "3 schema bourg en vol.bmp", "corr bourg en vol.bmp", "tileprop-V1-19.12.2011.txt", LARGEUR_TILE, HAUTEUR_TILE, LARGEUR_FENETRE, HAUTEUR_FENETRE);
 
	SDL_WM_SetCaption("Joueur sur carte avec collision et scrolling", NULL);
 
	screen = SDL_SetVideoMode(carte->largeur_fenetre, carte->hauteur_fenetre, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
 
    P = ChargerPerso("haut.bmp", "bas.bmp", "gauche.bmp", "droite.bmp", carte);
 
 
 
	while(!in.key[SDLK_ESCAPE] && !in.quit)
	{
	    lasttime = SDL_GetTicks();
		UpdateEvents(&in);
        Deplace(&in, &P, carte);//modifie position du joueur
		FocusScrollCenter(carte, &P);
 
		AfficherMap(carte, screen, &P, &in);
 
		SDL_Flip(screen);
		elapsed = SDL_GetTicks()-lasttime;
		if (elapsed<DELAY)
			SDL_Delay(DELAY-elapsed);
	}
	LibererMap(carte);
	SDL_Quit();
	return EXIT_SUCCESS;
}

fmap4.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
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
#include <string.h> //pour strmcp
#include "fmap4.h"
 
 
 
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 largeur_tile, int hauteur_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->largeur_tile = largeur_tile;
    res->hauteur_tile = hauteur_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)
    {
        printf("error :%s", SDL_GetError);
        exit(EXIT_FAILURE);
    }
 
    res->nbtiles = (res->tileset->w / largeur_tile) * (res->tileset->h / hauteur_tile);
    res->props = ChargerProps(tileprop,res->nbtiles);
    CalculerSDLRects(res->props,res->nbtiles,res->tileset->w / largeur_tile,largeur_tile,hauteur_tile);
    res->nbtiles_largeur_monde = IMGschema1->w;
    res->nbtiles_hauteur_monde = IMGschema1->h;
 
    res->Schema = malloc( 3*sizeof(char*)); // tableau de pointeurs sur pointeurs
    if(res->Schema == NULL)
    {
        printf("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;
	res->xscroll = 0;
	res->yscroll = 0;
 
    return res;
}
 
 
 
SDL_Surface* LoadImage32(const char* fichier_image,int vram) //convertit les images en 32 bits afin de faciliter leurs lectures aux pixels par pixels (vram -> blit ; ram -> pixel par pixel) et active la transparence de fond
{
	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 !!\t__FILE__\n\n",fichier_image);
		SDL_Quit();
		exit(EXIT_FAILURE);
	}
	image_result = NULL;
	if (vram)
		image_result=SDL_CreateRGBSurface(SDL_HWSURFACE, image_ram->w, image_ram->h, 32, 0, 0, 0, 0);  // cree une imageen 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
    SDL_SetColorKey(image_result, SDL_SRCCOLORKEY, SDL_MapRGB(image_result->format, 255, 255, 255));
	return image_result;
}
 
 
 
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 tileprop introuvable !!: %s\n",SDL_GetError());
        SDL_Quit();
        exit(EXIT_FAILURE);
    }
 
    for(i=0; i<nombre_props; i++)
    {
        fscanf(F,"%d %s",&useless,buf);
 
		 if (strcmp(buf,"vide")==0)
             res[i].vide = 1;
 
		if (strcmp(buf,"mur")==0)
            res[i].mur = 1;
 
        if (strcmp(buf,"blanc")==0)
            res[i].blanc = 1;
 
		printf("res[%d] -> mur =%d; blanc=%d; vide=%d\n\n", i, res[i].mur, res[i].blanc, res[i].vide); 
    }
    fclose(F);
    return res;
}
 
 
 
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);
    }
}
 
 
 
char LocatePixInCorr(SDL_Surface* corr, Uint32 pix)//retourne position du bon tile
{
    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;
}
 
 
 
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
}
 
 
 
Joueur ChargerPerso(const char* h, const char* b, const char* g, const char* d, Map* carte)
{
	Joueur P;
 
 
 
    P.ho = LoadImage32(h, 1);
    P.ba = LoadImage32(b, 1);
    P.go = LoadImage32(g, 1);
    P.dr = LoadImage32(d, 1);
    P.copy=P.ba;
 
    P.pos.x = 22*carte->largeur_tile;
    P.pos.y = 5*carte->hauteur_tile;
 
    return P;
}
 
 
 
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;
        default:
            break;
        case SDL_QUIT:
            in->quit = 1;
            break;
        }
    }
}
 
 
 
 
void Deplace(Input* in, Joueur* erwan, Map* m)
{
    char dirX, dirY;
    SDL_Rect test;
	dirX=dirY=0;
 
 
    if (in->key[SDLK_UP])
	{
		dirY = m->hauteur_tile;
		printf("haut\n");
	}
 
	if (in->key[SDLK_DOWN])
	{
		dirY = -(m->hauteur_tile);
		printf("bas\n");
	}
 
	if (in->key[SDLK_LEFT])
	{
		dirX = -(m->largeur_tile);
		printf("gauche\n");
	}
 
	if (in->key[SDLK_RIGHT])
	{
		dirX = (m->largeur_tile);
		printf("droite\n");
	}
 
    test = erwan->pos;
 
	test.x += dirX;
	test.y -= dirY;
 
 
 
    if(collisionDecor(m, &test)==0)//pas de collision
     {
		 erwan->pos = test;
	 }
}
 
 
 
int collisionDecor(Map* carte, SDL_Rect* perso)
{
    int xmin,xmax,ymin,ymax,i,j,indicetile;
 
	xmin = perso->x / carte->largeur_tile;//nombres de tiles avant d'arriver à celui où est le perso
	ymin = perso->y / carte->hauteur_tile;
	xmax = (perso->x + perso->w -1) / carte->largeur_tile;
	ymax = (perso->y + perso->h -1) / carte->hauteur_tile;
 
	if (xmin<0 || ymin<0 || xmax>=carte->nbtiles_largeur_monde || ymax>=carte->nbtiles_hauteur_monde)
		return 1;
 
	for(i=xmin;i<=xmax;i++)
	{
		for(j=ymin;j<=ymax;j++)
		{
			indicetile = carte->Schema[1][i][j];
			if (carte->props[indicetile].mur)
				return 1;
		}
	}
	return 0;
 
}
 
 
 
int AfficherMap(Map* m, SDL_Surface* screen, Joueur* P, Input* in)
{
    int h,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;
 
    SDL_FillRect(screen , NULL , 0xFFFFFF); // remplie de blanc l'ecran
 
 
    for(h=0; h<3; h++)
    {
		 if(h==2)
        {
            AfficherPerso(in, P, m, screen);
        }
 
		/* for(i=0; i<m->nbtiles_largeur_monde; i++)
        {
			for(j=0; j<m->nbtiles_hauteur_monde; j++)
            {
                Rect_dest.x = i * m->largeur_tile;
                Rect_dest.y = j * m->hauteur_tile;
                numero_tile = m->Schema[h][i][j];
 
                SDL_BlitSurface(m->tileset, &(m->props[numero_tile].R),screen, &Rect_dest);
            }
        }*/
 
		 for(i=minx; i<=maxx; i++)
        {
            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->Schema[h][i][j];
 
                SDL_BlitSurface(m->tileset, &(m->props[numero_tile].R),screen, &Rect_dest);
            }
        }
    }
 
 
    return EXIT_SUCCESS;
}
 
 
 
void AfficherPerso(Input* in, Joueur* P, Map* carte, SDL_Surface* screen)
{
	SDL_Rect positionsurecran = P->pos;
	positionsurecran.x -= carte->xscroll;
	positionsurecran.y -= carte->yscroll;
 
	//printf("positionsurecran.x = %d", positionsurecran.x);
 
    if(in->key[SDLK_UP])
    {
 
        P->copy = P->ho;
    }
 
    if(in->key[SDLK_DOWN])
    {
 
        P->copy = P->ba;
    }
 
    if(in->key[SDLK_LEFT])
    {
 
        P->copy = P->go;
    }
 
    if(in->key[SDLK_RIGHT])
    {
 
        P->copy = P->dr;
    }
 
    SDL_BlitSurface(P->copy, NULL, screen, &(positionsurecran));
}
 
 
 
int LibererMap(Map* m)
{
    int i, j;
 
    for(i=0 ; i < 3 ; i++)   //libération Schema
    {
        for(j=0 ; j < m->nbtiles_largeur_monde ; j++)
        {
            free(m->Schema[i][j]);
        }
        free(m->Schema[i]);
    }
    free(m->Schema);
 
 
 
    free(m->props);
    free(m);
    return EXIT_SUCCESS;
}
 
 
 
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 FocusScrollCenter(Map* carte,Joueur* perso)
{
	carte->xscroll = perso->pos.x + perso->pos.w/2 - carte->largeur_fenetre/2;
	carte->yscroll = perso->pos.y + perso->pos.h/2 - carte->hauteur_fenetre/2;
	ClampScroll(carte);
	return 0;
}

fmap4.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
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
#include <SDL/SDL.h>
#pragma warning(disable : 4996)
 
#define DELAY 70
#define LARGEUR_TILE 16
#define HAUTEUR_TILE 16
#define LARGEUR_FENETRE 240
#define HAUTEUR_FENETRE 160
 
 
typedef struct//évènement
{
	char key[SDLK_LAST];
	char quit;
} Input;
 
 
 
typedef struct//tableau avec propriétés
{
	SDL_Rect R;
	char mur, vide, blanc;
} TileProp;
 
 
 
typedef struct//structure map
{
	int largeur_tile,hauteur_tile;
	int nbtiles;
	TileProp* props;
	SDL_Surface* tileset;
	unsigned char ***Schema;
	int nbtiles_largeur_monde, nbtiles_hauteur_monde;
	int largeur_fenetre,hauteur_fenetre;
	int xscroll,yscroll;
} Map;
 
 
 
typedef struct//structure joueur
{
    SDL_Surface *ho, *ba, *go, *dr, *copy;
    SDL_Rect pos;
}Joueur;
 
 
 
 
 
 
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 largeur_tile, int hauteur_tile, int largeur_fenetre, int hauteur_fenetre);
 
 
 
SDL_Surface* LoadImage32(const char* fichier_image,int vram);
 
 
 
TileProp* ChargerProps(const char* tileprop, int nombre_props);
 
 
 
void CalculerSDLRects(TileProp* tabprops, int nombre_props, int nombre_tiles_largeur, int largeur_tile, int hauteur_tile);
 
 
 
char LocatePixInCorr(SDL_Surface* corr, Uint32 pix);
 
 
 
Uint32 GetPixel32(SDL_Surface* image, int i, int j);
 
 
 
Joueur ChargerPerso(const char* h, const char* b, const char* g, const char* d, Map* carte);
 
 
 
void UpdateEvents(Input* in);
 
 
int FocusScrollCenter(Map* carte,Joueur* perso);
 
 
 
 
 
 
 
 
 
 
void Deplace(Input* in, Joueur* erwan, Map* m);
 
 
 
int collisionDecor(Map* carte, SDL_Rect* perso);
 
 
 
int AfficherMap(Map* m,SDL_Surface* screen, Joueur* P, Input* in);
 
 
 
void AfficherPerso(Input* in, Joueur* P, Map* carte, SDL_Surface* screen);
 
 
 
int LibererMap(Map* m);

merci d'avance

PJ: ci-joint une archive winrar(http://www.megaupload.com/?d=URR7PNCV) avec l'application afin que vous puissiez voir de vous même les problèmes

**Kannagi** · 23/12/2011, 08h48

Alors chez moi il y a le scrolling avec ton code.
http://www.mediafire.com/?895c3x2a823c9sx

Sinon il n'y a jamais de collision

Code :

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

1
2
3
4
5
 
if(collisionDecor(m, &test)==0)//pas de collision
     {
		 erwan->pos = test;
	 }

j'ai mis dans la condition un printf("ok\n");
et il est toujours ok , donc il détecte jamais de collision,sauf les bord de la fenêtre.

Maintenant je vais te donner quelque conseil.
Pour le perso il est pas utile de chargé plein de fois plusieurs image.
j'imagien que tu as pris cette image http://spriters-resource.com/gameboy...rs/brendan.png
tu aurais tu l'as gardé dans la SDL .

Code :

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

SDL_BlitSurface(image,&tiles, screen, &position);

tiles et une structure du type SDL_Rect.

si je fait cela

Code :

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

1
2
3
4
tiles.x = 0;
tiles.y = 0;
tiles.w = 32;
tiles.h = 32;

La Sdl affichera qu'une partie du blit (il affichera les coordonné de x,y ,avec la largeur et hauteur de 32 pixel ici).

Donc je te conseille t'utilisé cette méthode (et ça t’évitera de chargés plein image.

Le code et a la fois bien et mauvais ,bien pensé (chargement/affichage,procédural , sans effet de bord), mais trop brouillon.
Je te conseille de faire une fonction fps avec la structure qui va avec , ça te sera plus 'pratique' .

Pour la logique du code en gros je te conseille de faire comme cela

(Je te laisse mettre les arguments des fonction).

Code :

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

1
2
3
4
5
6
7
8
 
Eventupdate();
gameplay(); //qui initialise la vitesse (vitesse.x = 0 , si on appuie sur fleche a droite vitesse.x = 3; par exemple.
colllision();//qui modifie la vitesse
deplacement(); //la position du perso , perso.x += vitesse.x;
Affichagemap();
Affichageperso();
fps();

Je te conseille de refaire les fonction en simplifiant, normalement ton gameplay,deplacement,et affichage perso ,et affichagemap , ne contient que quelque ligne 'simple' de code.

Bon mais pour Pokemon , si je me rappelle bien ,le perso se déplace de case en case donc ce n'est pas la même logique pour les collisions;
J’imagine qu'il se déplace de 32pixel en 32.
donc a chaque déplacement il doit se déplacé de 32 pixel (le mieux c'est de ne pas le faire d'un coup). ,il faut juste vérifié avant ,si on peut se déplacé.

**talonneur56** · 23/12/2011, 15h49

j'ai téléchargé ton application mais j'arrive pas à déplacer le perso.

Sinon il n'y a jamais de collision

Code :

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

1
2
3
4
if(collisionDecor(m, &test)==0)//pas de collision
{
erwan->pos = test;
}

j'ai mis dans la condition un printf("ok\n");
et il est toujours ok , donc il détecte jamais de collision,sauf les bord de la fenêtre.

oui je l'avais observé mais je ne comprends pas du tout pourquoi la fonction collisionDécor ne joue plus son rôle alors qu'en enlevant les parties du code s'occupant du scrolling ça marche nikel?!...

Pour le perso il est pas utile de chargé plein de fois plusieurs image.
j'imagien que tu as pris cette image http://spriters-resource.com/gameboy...rs/brendan.png
tu aurais tu l'as gardé dans la SDL .
SDL_BlitSurface(image,&tiles, screen, &position);

tiles et une structure du type SDL_Rect.

si je fait cela

Code :

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

1
2
3
4
5
6
 
 
tiles.x = 0;
tiles.y = 0;
tiles.w = 32;
tiles.h = 32;

La Sdl affichera qu'une partie du blit (il affichera les coordonné de x,y ,avec la largeur et hauteur de 32 pixel ici).

Donc je te conseille t'utilisé cette méthode (et ça t’évitera de chargés plein image.

c'est vrai sa serais quand même plus optimiser, je comptait le faire mais plus tard lorsque j'aurais beaucoup de sprites à gérer mais vu que tu me conseille de le faire, je vais m'en occuper dès que possible

Le code et a la fois bien et mauvais ,bien pensé (chargement/affichage,procédural , sans effet de bord), mais trop brouillon.
Je te conseille de faire une fonction fps avec la structure qui va avec , ça te sera plus 'pratique' .

Pour la logique du code en gros je te conseille de faire comme cela

(Je te laisse mettre les arguments des fonction).

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 
 
Eventupdate();
gameplay(); //qui initialise la vitesse (vitesse.x = 0 , si on appuie sur fleche a droite vitesse.x = 3; par exemple.
colllision();//qui modifie la vitesse
deplacement(); //la position du perso , perso.x += vitesse.x;
Affichagemap();
Affichageperso();
fps();

Je te conseille de refaire les fonction en simplifiant, normalement ton gameplay,deplacement,et affichage perso ,et affichagemap , ne contient que quelque ligne 'simple' de code.

d'après moi (mais peut être que je me trompe), ce que tu me propose et mon code (basé sur celui d'un tuto sur le SDZ) sont identiques ou presque vu qu'il est sans doute prévu pour un déplacement au pixel alors que dans le mien le perso se deplace de tile en tile

**Kannagi** · 23/12/2011, 16h45

Envoyé par talonneur56

j'ai téléchargé ton application mais j'arrive pas à déplacer le perso.

Étrange parce que moi je peux déplacé le perso ^^'

Envoyé par talonneur56

oui je l'avais observé mais je ne comprends pas du tout pourquoi la fonction collisionDécor ne joue plus son rôle alors qu'en enlevant les parties du code s'occupant du scrolling ça marche nikel?!...

Je n'ai pas lu vraiment ton code , vu que je le trouve un peu 'brouillon'.

Mais je sais peut etre pourquoi ,dans ce code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
printf("%d,%d\n",xmin,xmax);
	for(i=xmin;i<=xmax;i++)
	{
		for(j=ymin;j<=ymax;j++)
		{
			indicetile = carte->Schema[1][i][j];
			printf("%d,%d,%d\n",carte->Schema[1][i][j],i,j);
			if (carte->props[indicetile].mur == 1)
				return 1;
		}
	}

ben sur la console il m'affiche ça

Code :

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

22,21

Et donc il entre jamais dans ta boucle vu que la condition est que i <=xmax , mais vu que i est plus grand que xmax(et donc xmin est plus grand que xmax ^^').
en gros xmin = 22, et xmin = 21. Y'a un souci la XD

Sinon j'avoue j'ai mal regardé ton perso quand il se déplace, effectivement il déplace bien de tiles en tiles.

soucis dans tile mapping

SDL

Discussions similaires

Partager

Partager