Déplacer une même image qui à différente position de départ

**Brillant974** · 19/05/2011, 16h25

Bonjour,
J’essaie de programmé un petit jeu 2d en C avec la biblio SDL. Pour ce qui connaissent c'est blockdude un petit jeu qui consiste à déplacer des caisses pour créer son chemin et atteindre la porte de sorti. Je suis capable de déplace mon personnage, de le faire mon sur un obstacle, de le faire tomber lorsqu’il est dans le vide.

Enfaite j'arrive à gérer lorsqu'il s'agit de déplacer une image mais mon problème vient quand il s'agit de déplacer les caisses je ce n’est pas comment faire pour déplacer une même image mais qui se trouve à différente position sur ma carte.

Le problème c'est que pour créer ma carte j'utilise des coordonnés étant donnés que j'ai formalisé tout mes sprites à 32px sur 32px pour blitter les sprites je multiplie les X et Y coordonnés de ma carte par 32.Mais pour déplacer mes objet pour avoir un mouvement plus fluides et plus sympa j'ai préféré les déplacés pixel par pixel. C’est pour sa quand j'essaie de gérer les déplacements de mes caisse ben je plante!!!
Voici le code que j'utilise pour mon jeu:

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
443
444
445
446
447
448
449
450
451
452
453
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL_image.h>
 
 
#include "constantes.h"
#include "jeu.h"
#include "fichier.h"
 
int directionPerso = 0;
int caisse_ok = 0;
int positionxCaisse[100] = {0}, positionyCaisse[100] = {0}, numeroCaisse = 0;
 
void jouer(SDL_Surface *ecran)
{
SDL_Surface *persoActuel, *perso[8] = {0};
SDL_Surface *mur = NULL, *sol = NULL, *sous_sol = NULL, *magma = NULL, *caisse = NULL, *porte = NULL, *ciel = NULL, *nuage = NULL;
SDL_Rect position, positionJoueur, positionCaisse, posCaisseSauv;
SDL_Event event;
 
int continuer = 1;
int i = 0, j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
 
 
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 0, 0));
//Initialisation de tout les mouvement du perso
perso[GAUCHE_0] = IMG_Load("images/link_gauche_0.bmp");
perso[GAUCHE_1] = IMG_Load("images/link_gauche_1.bmp");
perso[GAUCHE_2] = IMG_Load("images/link_gauche_2.bmp");
perso[GAUCHE_3] = IMG_Load("images/link_gauche_3.bmp");
perso[DROITE_0] = IMG_Load("images/link_droite_0.bmp");
perso[DROITE_1] = IMG_Load("images/droite_1.bmp");
perso[DROITE_2] = IMG_Load("images/droite_2.bmp");
perso[DROITE_3] = IMG_Load("images/droite_3.bmp");
for (i=0;i < 8;i++) // gestion de la transparence
{
SDL_SetColorKey(perso[i], SDL_SRCCOLORKEY, SDL_MapRGB(perso[i]->format, 0, 0, 255));
}
mur = IMG_Load("images/mur.jpg");
sol = IMG_Load("images/sol.png");
sous_sol = IMG_Load("images/sous_sol.png");
magma = IMG_Load("images/magma.png");
caisse = IMG_Load("images/caisse.jpg");
porte = IMG_Load("images/porte.png");
ciel = IMG_Load("images/ciel.png");
nuage = IMG_Load("images/nuage.png");
 
position.x = 0;
position.y = 0;
 
chargerNiveau(carte);
 
for (i = 0; i < NB_BLOCS_LARGEUR; i++)
{
for (j = 0; j < NB_BLOCS_HAUTEUR; j++)
{
 
if (carte[i][j] == PERSO)
{
positionJoueur.x = i * TAILLE_BLOC;
positionJoueur.y = j * TAILLE_BLOC;
carte[i][j] = VIDE;
}
}
}
// Activation de la répétition des touches
SDL_EnableKeyRepeat(65, 65);
persoActuel = perso[GAUCHE_0]; // Initialisation du personnage
while(continuer)
{
SDL_WaitEvent(&event);
switch (event.type)
{
case SDL_QUIT :
continuer = 0;
break;
case SDL_KEYUP:
switch(event.key.keysym.sym)
{
case SDLK_LEFT:
persoActuel = perso[GAUCHE_0];
break;
case SDLK_RIGHT:
persoActuel = perso[DROITE_0];
break;
}
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym) //change les images pour donner un effet de déplacements
{
case SDLK_LEFT:
if (persoActuel == perso[GAUCHE_0])
{persoActuel = perso[GAUCHE_1];}
else if (persoActuel == perso[GAUCHE_1])
{persoActuel = perso[GAUCHE_2];}
else if (persoActuel == perso[GAUCHE_2])
{persoActuel = perso[GAUCHE_3];}
else if (persoActuel == perso[GAUCHE_3])
{persoActuel = perso[GAUCHE_0];}
else if (persoActuel == perso[DROITE_0])
{persoActuel = perso[GAUCHE_0];}
else if (persoActuel == perso[DROITE_1])
{persoActuel = perso[GAUCHE_0];}
else if (persoActuel == perso[DROITE_2])
{persoActuel = perso[GAUCHE_0];}
else if (persoActuel == perso[DROITE_3])
{persoActuel = perso[GAUCHE_0];}
directionPerso = GAUCHE;
deplacerPerso(carte, &positionJoueur, GAUCHE, &positionCaisse); //fonction qui permet de déplacer le perso
break;
case SDLK_RIGHT:
if (persoActuel == perso[GAUCHE_0])
{persoActuel = perso[DROITE_0];}
else if (persoActuel == perso[GAUCHE_1])
{persoActuel = perso[DROITE_0];}
else if (persoActuel == perso[GAUCHE_2])
{persoActuel = perso[DROITE_0];}
else if (persoActuel == perso[GAUCHE_3])
{persoActuel = perso[DROITE_0];}
else if (persoActuel == perso[DROITE_0])
{persoActuel = perso[DROITE_1];}
else if (persoActuel == perso[DROITE_1])
{persoActuel = perso[DROITE_2];}
else if (persoActuel == perso[DROITE_2])
{persoActuel = perso[DROITE_3];}
else if (persoActuel == perso[DROITE_3])
{persoActuel = perso[DROITE_0];}
directionPerso = DROITE;
deplacerPerso(carte, &positionJoueur, DROITE, &positionCaisse);
break;
case SDLK_UP:
if (directionPerso == GAUCHE)
{
persoActuel = perso[GAUCHE_0];
}
else if (directionPerso == DROITE)
{
persoActuel = perso[DROITE_0];
}
deplacerPerso(carte, &positionJoueur, HAUT, &positionCaisse);
break;
case SDLK_DOWN: // quand on appui sur la touche bas si il y a une caisse devant le perso sa le met au dessus de sa tête
if (carte[(positionJoueur.x - PAS_DEPLA) / TAILLE_BLOC][positionJoueur.y / TAILLE_BLOC] == CAISSE || carte[(positionJoueur.x + TAILLE_BLOC + PAS_DEPLA) / TAILLE_BLOC][positionJoueur.y / TAILLE_BLOC] == CAISSE )
{
prendreCaisse(carte, &positionJoueur, directionPerso, &positionCaisse);// fonction qui permet de déplacer la caisse
caisse_ok = 1;
 
}
 
else if (caisse_ok == 1)// si il y a déja une caisse qui est pris par le perso je la dépose
{
deposerCaisse(carte, &positionJoueur, directionPerso, &positionCaisse);// fonction qui permet de déposer une caisse
 
}
 
break;
}
break;
 
}
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255)); //effacer l'ecran
// Placement des objets à l'écran
for (i = 0 ; i < NB_BLOCS_LARGEUR; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ;j++)
{
position.x = i * TAILLE_BLOC;
position.y = j * TAILLE_BLOC;
switch(carte[i][j])
{
case SOL:
SDL_BlitSurface(sol, NULL, ecran, &position);
break;
case SOUS_SOL:
SDL_BlitSurface(sous_sol, NULL, ecran, &position);
break;
case MAGMA:
SDL_BlitSurface(magma, NULL, ecran, &position);
break;
case MUR:
SDL_BlitSurface(mur, NULL, ecran, &position);
break;
case CAISSE:
SDL_BlitSurface(caisse, NULL, ecran, &position);
break;
case PORTE:
SDL_BlitSurface(porte, NULL, ecran, &position);
break;
case CIEL:
SDL_BlitSurface(ciel, NULL, ecran, &position);
break;
case NUAGE:
SDL_BlitSurface(nuage, NULL, ecran, &position);
break;
}
}
}
// On place le joueur à la bonne position
SDL_BlitSurface(persoActuel, NULL, ecran, &positionJoueur);
// On place la caisse à la bonne position
if (caisse_ok == 1 || caisse_ok == 2 || caisse_ok == 3)
{
SDL_BlitSurface(caisse, NULL, ecran, &positionCaisse);
for (i=0;i<100;i++)
{
if (positionxCaisse[i] != 0)
{
posCaisseSauv.x = positionxCaisse[i]; //modifier! ici je c pas quoi faire
posCaisseSauv.y = positionyCaisse[i];
SDL_BlitSurface(caisse, NULL, ecran, &posCaisseSauv);
}
 
}
 
}
 
// Mise à jour de l'écran
SDL_Flip(ecran);
}// fin fonction jouer
SDL_FreeSurface(sol);// fin , on libere l'espace en mémoire
SDL_FreeSurface(sous_sol);
SDL_FreeSurface(magma);
SDL_FreeSurface(mur);
SDL_FreeSurface(caisse);
SDL_FreeSurface(porte);
SDL_FreeSurface(perso);
SDL_FreeSurface(ciel);
SDL_FreeSurface(nuage);
for (i = 0 ; i < 8 ; i++)
SDL_FreeSurface(perso[i]);
}// fin de la fonction jouer
 
void deplacerPerso(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction, SDL_Rect *posCaisse)
{
int i = 0, caisseTouche = 0;
tomberPerso(carte,pos, direction, posCaisse); //Fonction pour faire tomber le perso quand il est dans le vide
caisseTouche = 0;
for (i=0;i<100;i++)
{
if (pos->x + 1 == positionxCaisse[i] - TAILLE_BLOC)// la c modifié! je c pas quoi faire
{
caisseTouche = 1;
}
else if (pos->x - 1 == positionxCaisse[i] + TAILLE_BLOC) // modifié
{
caisseTouche = 2;
}
}
switch (direction)
{ // la on entre dans la gestion des collisions
case GAUCHE:
if (carte[(pos->x - PAS_DEPLA) / TAILLE_BLOC][pos->y / TAILLE_BLOC] < 0)
break;
if (carte[(pos->x - PAS_DEPLA) / TAILLE_BLOC][pos->y / TAILLE_BLOC] != VIDE)
break;
if (carte[(posCaisse->x - PAS_DEPLA) / TAILLE_BLOC][(posCaisse->y) / TAILLE_BLOC] != VIDE && caisse_ok == 1)// quand la caisse est porté si il percutte un obstacle il tombe.
{
posCaisse->x = posCaisse->x + TAILLE_BLOC;
posCaisse->y = posCaisse->y + TAILLE_BLOC;
caisse_ok = 2;
}
pos->x = pos->x - 3;
break;
case DROITE:
if (carte[(pos->x + PAS_DEPLA + TAILLE_BLOC) / TAILLE_BLOC][pos->y / TAILLE_BLOC] > LARGEUR_FENETRE)
break;
if (carte[(pos->x + PAS_DEPLA + TAILLE_BLOC) / TAILLE_BLOC][pos->y / TAILLE_BLOC] != VIDE)
break;
if (carte[(posCaisse->x + TAILLE_BLOC) / TAILLE_BLOC][(posCaisse->y) / TAILLE_BLOC] != VIDE && caisse_ok == 1)
{
posCaisse->x = posCaisse->x - TAILLE_BLOC;
posCaisse->y = posCaisse->y + TAILLE_BLOC;
caisse_ok = 2;
}
pos->x = pos->x + 3;
break;
case HAUT:
switch(directionPerso)
{
case GAUCHE:
if (carte[(pos->x - PAS_DEPLA) / TAILLE_BLOC][pos->y / TAILLE_BLOC] == VIDE)
break;
if (carte[(pos->x - PAS_DEPLA) / TAILLE_BLOC][(pos->y - TAILLE_BLOC) / TAILLE_BLOC] != VIDE)
break;
pos->x = pos->x - TAILLE_BLOC;
pos->y = pos->y - TAILLE_BLOC;
if (caisse_ok == 1)// permet a la caisse porté de bouger en meme temps que le perso
{
posCaisse->x = pos->x;
posCaisse->y = pos->y - TAILLE_BLOC;
}
break;
case DROITE:
if (carte[(pos->x + PAS_DEPLA + TAILLE_BLOC) / TAILLE_BLOC][pos->y / TAILLE_BLOC] == VIDE)
break;
if (carte[(pos->x + PAS_DEPLA + TAILLE_BLOC) / TAILLE_BLOC][(pos->y - TAILLE_BLOC) / TAILLE_BLOC] != VIDE)
break;
pos->x = pos->x + TAILLE_BLOC;
pos->y = pos->y - TAILLE_BLOC;
if (caisse_ok == 1)
{
posCaisse->x = pos->x;
posCaisse->y = pos->y - TAILLE_BLOC;
}
break;
}
break;
}
}// fin de la fonction déplacerPerso
void tomberPerso( int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction, SDL_Rect *posCaisse)
{
if (direction == GAUCHE)
{
if (carte[(pos->x - 15 + TAILLE_BLOC) / TAILLE_BLOC][(pos->y + TAILLE_BLOC) / TAILLE_BLOC] == VIDE || carte[(pos->x - 15 + TAILLE_BLOC) / TAILLE_BLOC][(pos->y + TAILLE_BLOC) / TAILLE_BLOC] == PORTE )
{
pos->x = pos->x + 21 - TAILLE_BLOC;
while(carte[(pos->x - 15 + TAILLE_BLOC) / TAILLE_BLOC][(pos->y + TAILLE_BLOC) / TAILLE_BLOC] == VIDE || carte[(pos->x - 15 + TAILLE_BLOC) / TAILLE_BLOC][(pos->y + TAILLE_BLOC) / TAILLE_BLOC] == PORTE)
{
pos->y = pos->y + 1;
}
 
}
}
if (caisse_ok == 1)// si le joueur porte une caisse permet a la caisse de suivre le joueur
{
posCaisse->x = pos->x;
posCaisse->y = pos->y - TAILLE_BLOC;
}
 
if (direction == DROITE)
{
if (carte[(pos->x + 15) / TAILLE_BLOC][(pos->y + TAILLE_BLOC) / TAILLE_BLOC] == VIDE || carte[(pos->x + 15) / TAILLE_BLOC][(pos->y + TAILLE_BLOC) / TAILLE_BLOC] == PORTE)
{
pos->x = pos->x - 20 + TAILLE_BLOC;
while(carte[(pos->x + 15) / TAILLE_BLOC][(pos->y + TAILLE_BLOC) / TAILLE_BLOC] == VIDE || carte[(pos->x + 15) / TAILLE_BLOC][(pos->y + TAILLE_BLOC) / TAILLE_BLOC] == PORTE)
{
pos->y = pos->y + 1;
}
 
}
}
if (caisse_ok == 1)
{
posCaisse->x = pos->x;
posCaisse->y = pos->y - TAILLE_BLOC;
}
}//fin de la fonction tomberPerso
 
int prendreCaisse(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction,SDL_Rect *posCaisse)
{
int i = 0;
switch (direction) // test s'il y a une caisse devant le perso
{
case GAUCHE:
if (carte[(pos->x - PAS_DEPLA) / TAILLE_BLOC][pos->y / TAILLE_BLOC] == CAISSE && carte[(pos->x) / TAILLE_BLOC][(pos->y - TAILLE_BLOC) / TAILLE_BLOC] == VIDE)
{
posCaisse->x = (pos->x - PAS_DEPLA) / TAILLE_BLOC;
posCaisse->y = (pos->y / TAILLE_BLOC);
carte[posCaisse->x][posCaisse->y] = VIDE;
}
posCaisse->x = (posCaisse->x + 1) * TAILLE_BLOC;
posCaisse->y = (posCaisse->y - 1) * TAILLE_BLOC;
 
break;
case DROITE:
if (carte[(pos->x + TAILLE_BLOC + PAS_DEPLA) / TAILLE_BLOC][pos->y / TAILLE_BLOC] == CAISSE && carte[(pos->x) / TAILLE_BLOC][(pos->y - TAILLE_BLOC) / TAILLE_BLOC] == VIDE)
{
posCaisse->x = (pos->x + PAS_DEPLA + TAILLE_BLOC) / TAILLE_BLOC;
posCaisse->y = (pos->y / TAILLE_BLOC);
carte[posCaisse->x][posCaisse->y] = VIDE;
}
posCaisse->x = (posCaisse->x - 1) * TAILLE_BLOC;
posCaisse->y = (posCaisse->y - 1) * TAILLE_BLOC;
break;
}
}// fin de la fonction prendreCaisse
 
int deposerCaisse(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction,SDL_Rect *posCaisse)
{
int i = 0;
switch (direction)
{
case GAUCHE:
//Test si la caisse percute un autre objet
if (carte[(posCaisse->x - TAILLE_BLOC - 1) / TAILLE_BLOC][posCaisse->y / TAILLE_BLOC] != VIDE)
break;
posCaisse->x = posCaisse->x - TAILLE_BLOC;
posCaisse->y = posCaisse->y + TAILLE_BLOC;
// Test si la caisse ce retrouve dans le vide
if(carte[(posCaisse->x + (TAILLE_BLOC/2)) / TAILLE_BLOC][(posCaisse->y + TAILLE_BLOC) / TAILLE_BLOC] == VIDE)
{
while (carte[(posCaisse->x) / TAILLE_BLOC][posCaisse->y / TAILLE_BLOC] != VIDE)
{
posCaisse->x++;
}
while (carte[(posCaisse->x + TAILLE_BLOC - 1) / TAILLE_BLOC][(posCaisse->y + TAILLE_BLOC) / TAILLE_BLOC] != VIDE)
{
posCaisse->x--;
}
while (carte[(posCaisse->x + (TAILLE_BLOC/2)) / TAILLE_BLOC][(posCaisse->y + TAILLE_BLOC) / TAILLE_BLOC] == VIDE)
{
posCaisse->y++;
}
 
}
for (i = 1; i < 5; i++)
{
if (carte[(posCaisse->x - 1) / TAILLE_BLOC][posCaisse->y / TAILLE_BLOC] == VIDE)
{
posCaisse->x--;
}
}
caisse_ok = 3;
break;
case DROITE:
//Test si la caisse percute un autre objet
if (carte[(posCaisse->x + ( 2 * TAILLE_BLOC) + 1) / TAILLE_BLOC][(posCaisse->y + TAILLE_BLOC) / TAILLE_BLOC] != VIDE)
break;
posCaisse->x = posCaisse->x + TAILLE_BLOC;
posCaisse->y = posCaisse->y + TAILLE_BLOC;
// Test si la caisse ce retrouve dans le vide
if(carte[(posCaisse->x + TAILLE_BLOC - (TAILLE_BLOC/2)) / TAILLE_BLOC][(posCaisse->y + TAILLE_BLOC) / TAILLE_BLOC] == VIDE)
{
while (carte[(posCaisse->x + TAILLE_BLOC + 1) / TAILLE_BLOC][(posCaisse->y + TAILLE_BLOC) / TAILLE_BLOC] != VIDE)
{
posCaisse->x--;
}
while (carte[(posCaisse->x + TAILLE_BLOC) / TAILLE_BLOC][(posCaisse->y + TAILLE_BLOC) / TAILLE_BLOC] != VIDE)
{
posCaisse->x++;
}
while (carte[(posCaisse->x + (TAILLE_BLOC/2)) / TAILLE_BLOC][(posCaisse->y + TAILLE_BLOC) / TAILLE_BLOC] == VIDE)
{
posCaisse->y++;
}
}
for (i = 1; i < 10; i++)
{
if (carte[(posCaisse->x + TAILLE_BLOC) / TAILLE_BLOC][posCaisse->y / TAILLE_BLOC] == VIDE)
{
posCaisse->x++;
}
}
caisse_ok = 3;
break;
}
positionxCaisse[numeroCaisse] = posCaisse->x; // ici je c pas quoi faire j'ai mis pour stocké la position de mai caisse dans un tableau
positionyCaisse[numeroCaisse] = posCaisse->y;
numeroCaisse++;
} //fin de la fonction deposerCaisse

**LittleWhite** · 23/05/2011, 01h25

Bonjour,

Afin d'avoir un déplacement fluide comme vous voudriez le faire, il faudrait avoir une liste de caisses sur la carte. Pourquoi ? Car comme cela, ce n'est pas la carte qui déterminerai la position des caisses, mais les caisses elles mêmes. Du coup, si on veut faire une déplacer fluide, on ne dépend plus de la carte.

En code, cela demande un certain changement dans votre méthode de faire. Notamment, vous aurez je pense, une structure Caisse et une liste (tableau). Il vous faudra une fonction déplacer caisse.

Et en dernier conseil:
Séparez votre projet en plusieurs fichiers logiques.

**Brillant974** · 25/05/2011, 15h33

Bonjour,

Merci d'avoir répondu LittleWhite je comprends l'utilité de ce que tu ma expliqué, et d'ailleurs c'était une des solutions que j'avais envisagé au début mais je suis un novice en programmation surtout du langage C, c'est pour sa comme ta pu constater j'ai un gros manque de méthode.
Est ce que tu pourrais me faire un petit algo qui me permettrai de déplacement mes caisses ou bien de m'indique un tuto qui me permettrai d'apprendre à en faire stp. Parce que je ne vois pas du tout comment faire??

**kev38300** · 04/06/2011, 13h09

Des que tu détecte une collision entre ton bonhomme et ta caisse (fait une fonction séparée du main pour ça

) tu regarde si ya pas de mur ou une autre caisse blitter et la tu change la position de ta caisse d'un carreau (32 pixel si g bien compris) mais je ne comprend pas sur quoi tu bloque?

Déplacer une même image qui à différente position de départ

SDL

Discussions similaires

Partager

Partager