Deplacement de sprite avec SDL en langage c

1 pièce(s) jointe(s)

bonjour a tous
voila j'essaye de faire deplacer des sprite avec un fond d'ecran
mais le sprite ne veux pas bouger
voici le code

Code:

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
 
SDL_Event Event;
SDL_Rect rect, dst,dstblue;
Uint8 *keys;
SDL_Surface  *image,*terrain = NULL, *panier=NULL, *screen_jeu =NULL, *sprite1= NULL, *ballon = NULL;
void jeu()
{     Uint32 temps_courant, prochain_rendu =0;
bool done = false;
    image[4];
    Sprite spControlable;
   if(SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        printf("Can't init SDL:  %s\n", SDL_GetError());
        exit(1);
    }
    atexit(SDL_Quit); 
 
 
     SDL_WM_SetCaption ("Basket", NULL);
    screen_jeu = SDL_SetVideoMode(1024, 655, 16, SDL_HWSURFACE | SDL_DOUBLEBUF);
 
    if(screen_jeu == NULL)
    {
        printf("Can't set video mode: %s\n", SDL_GetError());
        exit(1);
    }
 
    image = IMG_Load("./image/sprite/joueur1.gif");
    if(image == NULL)
    {
        printf("Can't load image of tux: %s\n", SDL_GetError());
        exit(1);
    } 
 
 
   if (!chargerSprite (&spControlable, "./image/sprite/pecheur.jpeg"))
 
      {  
         atexit(SDL_Quit);
 
         }
 
errain=IMG_Load("./image/terrain.bmp");
panier=IMG_Load("./image/panier.bmp");
ballon = IMG_Load("./image/ballon.bmp");
// On place le sprite a l'ecran
spControlable.dest.x=500;
spControlable.dest.y=260;
fixerDirectionSprite( &spControlable, DIRECTION_DROITE);
fixerDirectionSprite ( &spControlable, AUCUNE_DIRECTION);
 
    SDL_SetColorKey(image, SDL_SRCCOLORKEY, SDL_MapRGB(image->format, 255, 255, 255)); 
      SDL_SetColorKey(ballon, SDL_SRCCOLORKEY, SDL_MapRGB(ballon->format, 255, 255, 255));     
    while(!done)
    {
        while(SDL_PollEvent(&Event))
        {
            switch(Event.type)
            {  case SDL_KEYDOWN:
                    switch (Event.key.keysym.sym)
 
                    { 
                      case SDL_QUIT:
                      done = true;
                      break;
 
                      case SDLK_ESCAPE:
 
                           break;
                         // On deplace le sprite au clavier
                      case SDLK_RIGHT:
                           fixerDirectionSprite(&spControlable,DIRECTION_DROITE);
                           break;
                      case SDLK_LEFT:
                            fixerDirectionSprite(&spControlable,DIRECTION_GAUCHE);
                            break;
 
 
                            }
                            break;
 
               case SDL_KEYUP:
 
                    switch (Event.key.keysym.sym)
 
                           { 
 
                                case SDLK_RIGHT:
                                     if (spControlable.direction == DIRECTION_DROITE)
                                        fixerDirectionSprite (&spControlable,AUCUNE_DIRECTION);
                                     break;
 
                                case SDLK_LEFT:
 
                                     if (spControlable.direction == DIRECTION_GAUCHE)
                                          fixerDirectionSprite (&spControlable, AUCUNE_DIRECTION);
                                          break;
                                    case  SDLK_ESCAPE:
                                          sortie();      
                                          break;
                                          default: ;
                           }
 
                           break;
 
                           default:;
 
                       } 
        }            
 
      temps_courant==SDL_GetTicks();
 
      if (temps_courant > prochain_rendu)
{
      prochain_rendu = temps_courant +20;
 
 
 
      miseAJourSprite( &spControlable);
 
 
 
      SDL_FillRect(screen_jeu,NULL,0);
apply_surface(0,0,terrain,screen_jeu);
  apply_surface(220,210,panier,screen_jeu);
  apply_surface(400,500,ballon,screen_jeu);
  //SDL_FillRect(screen_jeu, &dstblue, SDL_MapRGB(screen_jeu->format, 0, 0, 255));
  //SDL_BlitSurface(image, NULL, screen_jeu, &dst);
  // on dessine le sprite a l'ecran
  dessinerSprite (&spControlable,screen_jeu);
  /* on met a jour la zone d'affichage de la fenetre */
  SDL_UpdateRect(screen_jeu,0, 0, 0,0);
    SDL_Flip(screen_jeu);
    }
 
}
    SDL_FreeSurface(terrain);
    SDL_FreeSurface(panier);
       SDL_FreeSurface(image);
     SDL_FreeSurface(ballon);
     supprimerSprite(&spControlable);
     SDL_Quit();
}

et voici le fichier sprite.c

Code:

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
 
 
   typedef struct
{
 // pour l'affichage
 
 SDL_Surface *image;
 SDL_Rect source;
 SDL_Rect dest;
 
 // taille du sprite
 int largeur;
 int hauteur;
 
 // pour le déplacement
 
 // direction dans laquelle se deplace le sprite
 int direction;
 
 // vitesse du sprite
 int vitesse;
 
 // pour la gestion des animations
 
 // si le sprite est anime
 int anim;
 
 // direction dans laquelle est orienté le sprite
 int orientation;
 // animation courante du sprite
 int anim_courante;
 // le temps que dure une animation
 int temps_anim;
 // le temps de l'animation courante
 int temps_anim_courante;
 // nombre d'animations du sprite
 int total_anims;
}Sprite;
 
#define HAUT 0
#define DROITE 1
#define BAS 2
#define GAUCHE 3
#define AUCUNE_DIRECTION 0
#define DIRECTION_HAUT  1
#define DIRECTION_DROITE 2
#define DIRECTION_BAS  4
#define DIRECTION_GAUCHE 8
#define LARGEUR_ECRAN 1024
#define HAUTEUR_ECRAN 655
 
SDL_Surface *loadBmp(const char *fichier)
{
 SDL_Surface *image;
 /* Chargement du bitmap "fichier" en memoire dans la surface image */
 image = SDL_LoadBMP(fichier);
 if ( image == NULL )
 {
  fprintf(stderr, "Echec de chargement du fichier %s : %s.\n", fichier, SDL_GetError());
  return NULL;
 }
 
 /* Verification du format de l'image */
 if ( (image->w != 128) || (image->h != 128) )
 if ( image == NULL )
 {
  fprintf(stderr, "L'image du fichier %s doit être de taille 96*128 pixels.\n", fichier);
  SDL_FreeSurface(image);
  return NULL;
 }
 
 return image;
}
int chargerSprite( Sprite *sprite, const char *image )
{
 sprite->image = loadBmp( image );
 if ( !sprite->image )
  return 0;
 
 // on fixe la cle de transparance
 SDL_SetColorKey( sprite->image, SDL_SRCCOLORKEY, SDL_MapRGB( sprite->image->format, 255, 0, 0) );
 // On definit d'abord les propriétés du sprite :
 
 // le sprite n'est pas animé par defaut
 sprite->anim = 0;
 // on commence par la première animation
 sprite->anim_courante = 0;
 // le sprite dispose de trois animations
 sprite->total_anims = 4;
 // par défaut, le sprite est tourné vers le bas
 sprite->orientation = DROITE;
 // chaque animation dure 5 affichages
 sprite->temps_anim = 8;
 // Le temps qu'il reste à afficher l'animation courante
 sprite->temps_anim_courante = 0;
 // On definit ensuite les dimentions du sprite.
 sprite->largeur = 32;
 sprite->hauteur = 32;
 
 sprite->source.x = sprite->anim_courante * sprite->largeur;
 sprite->source.y = sprite->orientation * sprite->hauteur;
 sprite->source.w = sprite->largeur;
 sprite->source.h = sprite->hauteur;
 sprite->dest.x = 0;
 sprite->dest.y = 0;
 sprite->dest.w = sprite->largeur;
 sprite->dest.h = sprite->hauteur;
 
 // on definit enfin la vitesse et la direction du sprite
 sprite->vitesse = 2;
 sprite->direction = AUCUNE_DIRECTION;
 
 return 1;
}
void supprimerSprite( Sprite *sprite )
{
 SDL_FreeSurface( sprite->image );
}
void fixerDirectionSprite( Sprite *sprite, int direction )
{
 // On affecte la direction au sprite
 sprite->direction = direction;
 
 // on affecte l'animation correcpondant à la direction au sprite
 if (direction != AUCUNE_DIRECTION)
 {
  sprite->anim = 1;
  switch (direction)
  {
  case DIRECTION_HAUT:
   sprite->orientation = HAUT;
   break;
 
  case DIRECTION_DROITE:
   sprite->orientation = DROITE;
   break;
  case DIRECTION_BAS:
   sprite->orientation = BAS;
   break;
  case DIRECTION_GAUCHE:
   sprite->orientation = GAUCHE;
   break;
  default:
   ;
  }
 }
 else
  // si le sprite est areté, on ne l'anime pas
  sprite->anim = 0;
 // on met la première animation
 sprite->anim_courante = 0;
 sprite->temps_anim_courante = 0;
 // on regle la source de l'image à copier
 sprite->source.y = sprite->orientation * sprite->hauteur;
 sprite->source.x = sprite->anim_courante * sprite->largeur;
}
void miseAJourSprite( Sprite *sprite )
{
 // le sprite vas vers le haut
 if (sprite->direction & DIRECTION_HAUT)
 {
  // on monte et on faut attention a ne pas sortie de l'ecran
  sprite->dest.y -= sprite->vitesse;
  if (sprite->dest.y < 0)
   sprite->dest.y = 0;
 }
 else if (sprite->direction & DIRECTION_DROITE)
 {
  // on va à droite et on fait attention a ne pas sortie de l'ecran
  sprite->dest.x += sprite->vitesse; 
  if (sprite->dest.x + sprite->largeur > LARGEUR_ECRAN) 
   sprite->dest.x = LARGEUR_ECRAN - sprite->largeur;
 }
 else if (sprite->direction & DIRECTION_BAS)
 {
  // on descend et on faut attention a ne pas sortie de l'ecran
  sprite->dest.y += sprite->vitesse; 
  if (sprite->dest.y + sprite->hauteur > HAUTEUR_ECRAN)
   sprite->dest.y = HAUTEUR_ECRAN - sprite->hauteur;
 }
 else if (sprite->direction & DIRECTION_GAUCHE)
 {
 
  sprite->dest.x -= sprite->vitesse; 
  if (sprite->dest.x < 0)
   sprite->dest.x = 0;
 }
}
void dessinerSprite( Sprite *sprite, SDL_Surface *destination )
{
 /* si le sprite est animé, on gere l'animation */
 if (sprite->anim)
 {
   sprite->temps_anim_courante--;
  // et on regarde s'il est temps de changer d'animation
  if ( sprite->temps_anim_courante <= 0 )
  {
   // s'il faut changer, on passe à l'animation suivante
   sprite->anim_courante++;
   // si on était à la dernière animation, on repasse à la première
   if (sprite->anim_courante >= sprite->total_anims)
    sprite->anim_courante = 0;
 
 
   sprite->source.x = sprite->largeur * sprite->anim_courante;
   sprite->temps_anim_courante = sprite->temps_anim;
  }
 }
 SDL_BlitSurface( sprite->image, &sprite->source, destination, &sprite->dest );
}

lorsque j'execute le personnage ne bouge pas
en fichier joint le sprite
voila
merci pour vos reponse

Je n'ai pas tout regarder mais je trouve que tes fonctions sont un peu longues et tu pourrais sûrement gagner en clareté de code si tu séparais un peu les fonctions. Par exemple, dans ta fonction jeu tu pourrais avoir une fonction init qui fait tout le travail des chargements des images...

Mais bon, c'est un goût personnel... Autre problème, j'ai du mal à voir la fin des fonctions puisque tu ne sautes pas toujours de lignes entre...

Ton problème se situe dans la mauvaise gestion de ta variable direction... En effet, tu confonds la variable orientation et direction ce qui bien sûr va poser des problèmes...

Dans ta fonction fixerDirection, ceci serait mieux (ou quelque chose qui y ressemble, je n'ai pas pu tester):
Code:

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 switch (direction) { case DIRECTION_HAUT: sprite->orientation = HAUT; sprite->direction = AUCUNE_DIRECTION; break; case DIRECTION_DROITE: sprite->orientation = DROITE; if(sprite->direction != GAUCHE) sprite->direction = DROITE; else sprite->direction = AUCUNE_DIRECTION; break; case DIRECTION_BAS: sprite->orientation = BAS; sprite->direction = AUCUNE_DIRECTION; break; case DIRECTION_GAUCHE: sprite->orientation = GAUCHE; if(sprite->direction != DROITE) sprite->direction = GAUCHE; else sprite->direction = AUCUNE_DIRECTION; break; default: ; }
Jc

merci pour la reponse

c'est bon ca marche avec ce que tu m'a dit

oui apres je vais decomposer en fonction avec init

de plus la je n'ai pas saute de ligne car le post est limite a 1000 caractere

merci

programme

salut fab101.
Je t'envoie ce message car j'ai comme projet de réaliser un cartoon en langage c sur linux et ton projet pourrais beaucoup m'aider car c'est le meme principe de déplacement de sprite sur un fond d’écran .
Je te demande donc si tu pouvais m'envoyer ton programme complet avec les images utilisé etc .. s'il te plait si cela ne te dérange pas pour m'aider .

Merci beaucoup d'avance . =) :ccool: