Discussion :

[grincheux01]

Bonjour à tous,

Je vous propose le code source d'un début de casse-brique écrit en C et utilisant la bibliothèque de fonction SDL pour l'affichage 2D.

Ce code gére le déplacement d'un sprite dépendant de l'utilisation du clavier , il gére aussi la transparence sur un fond.

Tous les sprites utilisés sont au format png , ce qui veut dire que j'utilise la librairie SDL_Image.

A terme, si mon code est assez lisible et efficace , cette contribution servira de base pour élaborer un casse-brique.

[grincheux01]

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
 
//fichier standart d'entree-sortie
#include <stdio.h>
#include <stdlib.h>
 
//fichier necessaire a l'utilisation de sdl
#include "SDL.h"
#include "SDL_image.h"
 
const int MIN_WIDTH = 0;
const int MAX_WIDTH = 800;
 
int quit =0;
int ballOnPaddle=1;
 
//raquette
const Sint16 base_velocity = 2;
Sint16 velocity_left = 0;
Sint16 velocity_right = 0;
//balle
Sint16 ball_velocity_x = 1;
Sint16 ball_velocity_y = -2;
 
 
//Les surfaces
SDL_Surface *screen = NULL;
SDL_Surface *raquette_image=NULL;
SDL_Surface *balle_image=NULL;
SDL_Surface *fond_image=NULL;
 
SDL_Rect balle_location;
SDL_Rect raquette_location;
SDL_Rect fond_location;
 
 
void process_events(void)
{
     SDL_Event event;
     Uint8* keystate;
 
     if(SDL_PollEvent(&event))
      {
        if(event.type == SDL_KEYDOWN)
        {
         if(event.key.keysym.sym == SDLK_ESCAPE)
          {
            quit = 1;
          }
          else if (event.key.keysym.sym == SDLK_SPACE)
          {
            ballOnPaddle = 0;
          }
        }
 
      }
      keystate = SDL_GetKeyState(0) ;
      velocity_left = (keystate[SDLK_LEFT] ? base_velocity : 0);
      velocity_right = (keystate[SDLK_RIGHT] ? base_velocity : 0);    
 
}
 
int init()
{
    //initialisation de tout les sous-systemes de sdl
    if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
    {
        return 1;
    }
 
    //on met en place l'ecran
    screen = SDL_SetVideoMode( 800, 600, 32, SDL_SWSURFACE );
 
    //Si il y a une erreur lors de la mise en place de l'ecran
    if( screen == NULL )
    {
        return 1;
    }
 
    //on met en place la barre caption de la fenetre
    SDL_WM_SetCaption( "Casse Brique", NULL );
 
    //si tout s'est bien passé
    return 1;
}
 
 
 
void EnsureIsInPlayground(SDL_Rect *location) 
{
 
  if(location->x < MIN_WIDTH) 
  {
    location->x = MIN_WIDTH;
  }
  if(location->x + location->w > MAX_WIDTH) 
  {
    location->x = MAX_WIDTH - location->w;
  }                        
}
 
SDL_Surface *load_image(unsigned char * filename )
{
    //L'image qui est chargée
    SDL_Surface* loadedImage = NULL;
    //L'image optimisée que nous utiliserons par la suite
    SDL_Surface* optimizedImage = NULL;
    //Chargement de l'image
    loadedImage = IMG_Load( filename);
 
    //Si l'image est chargée
    if( loadedImage != NULL )
    {
        //creation de l'image optimisée
        optimizedImage = SDL_DisplayFormat(loadedImage );
 
        //liberation de l'ancienne image
        SDL_FreeSurface( loadedImage );
 
        //si l'image optimisée créé est bonne
        if( optimizedImage != NULL )
        {
            Uint32 colorkey = SDL_MapRGB( optimizedImage->format, 255, 255, 255);
            //on met tout les pixel de couleur R 0, G 0xFF, B 0xFF transparent
            SDL_SetColorKey( optimizedImage, SDL_RLEACCEL | SDL_SRCCOLORKEY, colorkey );
        }
    }
    //on retourne l'image optimisé
    return optimizedImage;
}    
 
SDL_Rect apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination )
{
    //rectangle temporaire
    SDL_Rect offset;
 
    offset.x = x;
    offset.y = y;
 
    return offset;
 
}
 
int load_files()
{
    //on charge l'image qu'on va appliquer sur le fond
    raquette_image = load_image( "AquaRaquette.png" );
 
    //si l'image se charge mal
    if( raquette_image == NULL )
    {
        return 0;
    }
    //chargement du background
    balle_image = load_image( "AquaBall.png" );
 
    //si le fond ne se charge pas
    if( balle_image == NULL )
    {
        return 0;
    }
 
    //chargement du background
    fond_image = load_image( "fond.png" );
 
    //si le fond ne se charge pas
    if( fond_image == NULL )
    {
        return 0;
    }
    return 1;
}
 
void clean_up()
{
    //Liberation des surfaces 
    SDL_FreeSurface( raquette_image );
    SDL_FreeSurface( balle_image );
    SDL_FreeSurface( fond_image );
 
    //On quitte SDL
    SDL_Quit();
}
 
int IsCollision(int x1,int y1,int L1,int H1,int x2,int y2, int L2,int H2)
{
 // teste si les rectangles donnés par les paramètres se touchent
 // (Ax,Ay = point en haut à gauche du premier rectangle
 //  Aw, Ah = largeur et hauteur du premier rectangle)
 // (Bx,By = point en haut à gauche du second rectangle
 //  Bw, Bh = largeur et hauteur du second rectangle)
 if (y1+H1 < y2) return(0);
 if (y1 > y2+H2) return(0);
 
 if (x1+L1 < x2) return(0);
 if (x1 > x2+H2) return(0);
 
 return 1;
}
 
void MoveBall(void)
{
     if(ballOnPaddle==1)
     {
      balle_location=apply_surface( raquette_location.x+16, raquette_location.y-12, balle_image, screen );        
     }
     else
     {
      balle_location.x+= ball_velocity_x;
      balle_location.y+= ball_velocity_y;
      if(balle_location.x > (800 - balle_location.w)) 
      {
       ball_velocity_x = -ball_velocity_x;
      }
      if(balle_location.y < 0) 
      {
       ball_velocity_y = -ball_velocity_y;
      }
      if(balle_location.x < 0) 
      {
       ball_velocity_x = -ball_velocity_x;
      }
 
        if((IsCollision(raquette_location.x,raquette_location.y,raquette_location.w,raquette_location.h,balle_location.x,balle_location.y,balle_location.w,balle_location.h)> 0 ))
	{
		ball_velocity_y = -ball_velocity_y;
	}
     }
}
 
int main(int argc, char *argv[])
{
    //Initialisation
    if( init() == 0 )
    {
        return 1;
    }
 
       //chargement des fichiers
    if( load_files() == 0 )
    {
        return 1;
    }
 
 
    //Application des surfaces sur l'ecran
    fond_location=apply_surface( 0, 0, fond_image, screen );
    raquette_location=apply_surface( 400, 580, raquette_image, screen );   
 
    while(quit==0) 
    {
     process_events();   
     raquette_location.x += (-velocity_left + velocity_right);
     EnsureIsInPlayground(&raquette_location); 
     MoveBall();
     SDL_BlitSurface(fond_image, 0, screen, &fond_location);
     SDL_BlitSurface(balle_image, 0, screen, &balle_location);
     SDL_BlitSurface(raquette_image, 0, screen, &raquette_location);
     SDL_Flip(screen);
    }
 
    clean_up();
 }

[grincheux01]

Ici je vous laisse le code source avec les images : http://rapidshare.de/files/21845393/...rique.zip.html

Edit : j'enverrais ce fichier sur ftp lorsque je pourrais le faire

[Laurent Gomila]

Merci pour cette contribution

Tiens nous au courant si tu fais évoluer le code.

[grincheux01]

oui il risque d'évoluer, car je veux le coder sur une console coréenne la gp2x cette derniere gére SDL donc tres facile a programme

[Laurent Gomila]

Je vais intégrer cette première version à la première mouture de la page sources SDL. Si tu préfères attendre une prochaine version dis le moi.

Est-ce qu'elle est fonctionnelle à 100 % ? Peux-tu nous faire un petit screenshot sympa ?

[loka]

Je vais la tester ce soir

[grincheux01]

L'affichage et le déplacement fonctionne très bien , il y a juste la collision qui a un soucis, je travail dessus.

Le probleme est que si la balle touche la barre juste a un pixel donné,elle reste collée.

[fearyourself]

L'affichage et le déplacement fonctionne très bien , il y a juste la collision qui a un soucis, je travail dessus.

Le probleme est que si la balle touche la barre juste a un pixel donné,elle reste collée.

A chaque collision, multiplie la vitesse par -1 si c'est nécessaire par exemple si la balle est trop sur la droite, faut multiplier si la vitesse est >0.

Pour la barre, calcule un vecteur du centre de la barre au centre de la balle, calcule le produit scalaire entre ce vecteur et le vecteur de vitesse, multiplie par -1 seulement si le résultat était négatif. Cela forcera la balle a partir de la barre...

Enfin, s'il y a une collision, changer la vitesse n'est pas suffisant, remet la balle à son ancienne position. Cela permet de "garantir" qu'il n'y a pas de collision après ta fonction.

Preuve récursive :

Code :

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

1
2
Avant mise à jour : Etat sans collision
On bouge les objets, si on remarque une collision on remet la balle à sa position de départ où il n'y a pas de balle/barre puique l'état état sans collision...

Bonne chance,
Jc