Jeu de boules en C avec SDL

1 pièce(s) jointe(s)

Bonjour,

Je suis actuellement étudiant en prémière année. Nous sommes très peu encadrés et nous avons chacun un projet en C avec SDL à rentre très vite.
J'ai décidé de créer un jeu de boule fortement inspiré du BubbleShooter, puisque c'est un jeu qui me passionne, et savoir comment le programmer serait pour moi très bénéfique.
Cependant, je n'ai pas énormément de connaissances en programmation en C.

Voici un appercu du jeu que j'aimerais otenir :

Pièce jointe 106935

J'ai donc commencé à écrire un code, qui a mon sens est très brouillon puisque C et SDL sont mélangés, donc si je venais à changer de Bibliothèque, ce serait problématique, m'enfin.
Ce que j'ai écrit, après compilation et exécution, m'affiche mon terrain, mes boules, et une boule aléatoire pour le lanceur. (J'utilise codeblocks)

Par contre, je suis maintenant bloquée. Je n'ai absolument aucune idée de comment continuer, comme faire tirer la boule, faire disparaitre les boules après chaque tirs, ect..
Cela fait 3 jours que j'essaye de nombreuses manoeuvres, en vain. Alors je viens vous demander de l'aide ici.

Je suis vraiment deséspérée, mais ce projet me tient vraiment à coeur, et j'aimerais beaucoup le terminer dans la semaine qui arrive, alors si quelqu'un pouvait m'apporter de l'aide, quelle qu'elle soit, je lui en serais vraiment reconnaissant ! Et je me ferais un plaisir de montrer mon début de projet, pour avoir de l'aide..

Merci d'avance.

Bonjour,

As tu déjà créé la structure de la boucle principale du programme : détection des évènements (souris , clavier) et affichage des différents sprites ?

Bonsoir,

Bah j'ai une boucle d’évènement, oui, mais il me semble qu'elle ne fonctionne pas correctement.

Poste toujours ton code, que l'on voie où tu en es...

Bien sure, donc je pose mes .c

J'ai un premier fichier ecran.c
Vous pouvez remarquer que dans ce fichier j'ai essayer d'afficher la trajectoir du lanceur, mais ça ne fonctionne pas correctement.

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
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
#include "ecran.h"
 
 
int affiche_menu(SDL_Surface *ecran, Plateau *plateau)
{
        /* Initialisation du SDL Video */
        if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
        {
            printf( "Erreur initialisaion de SDL: %s\n", SDL_GetError() );
            return 1;
        }
 
        /* Verifier si SDL libere la memoire alouee quand elle ferme */
        atexit(SDL_Quit);
 
        /* Creation d'une nouvelle fenentre de video */
        ecran = SDL_SetVideoMode(393, 675, 32,SDL_HWSURFACE);
        if ( !ecran )
        {
            printf("Echec de creation de l'ecran video: %s\n", SDL_GetError());
            return 1;
        }
        SDL_WM_SetCaption("Bubble Shoot !", NULL);
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
        SDL_Flip(ecran);
 
       /* Télécharger l'image du menu */
        SDL_Surface* bmp_image = IMG_Load("../menu/menu.jpg");
        if (!bmp_image)
        {
            printf("Erreur de chargement du bitmap: %s\n", SDL_GetError());
            return 1;
        }
 
        /* Positions de l'image sur l'ecran */
        SDL_Rect position;
 
        position.x = 0;
        position.y = 0;
 
        /* Dessine l'image sur l'ecran */
        SDL_BlitSurface(bmp_image, NULL, ecran, &position);
        SDL_Flip(ecran);
 
 
        int continuer=1;
        while (continuer)
        {
            SDL_Event event;
            while (SDL_PollEvent(&event))
            {
                switch (event.type)
                {
                   case SDL_QUIT:
                                  continuer=0;
                                  break;
 
                   case SDL_KEYDOWN:
                        /* Sortie si la touche echapper est appuiee */
                        switch (event.key.keysym.sym)
                            {
                                case SDLK_ESCAPE: // Veut arrêter le jeu
                                continuer = 0;
                                break;
                                    case SDLK_KP1: // Demande à jouer
                                    affiche_plateau (ecran, plateau); // Chargement du premier niveau de jeu
                                    break;
                            }
 
		   case SDL_MOUSEBUTTONUP:
			if (event.button.button == SDL_BUTTON_LEFT)
				printf("%d, %d \n", event.button.x, event.button.y) ;
			break ;
 
                }
            }
        }
 
        /* Liberation de la memoire pour l'ecran */
        SDL_FreeSurface(bmp_image);
        SDL_FreeSurface(ecran);
 
 
        printf("Sortie avec succes \n");
        return 0;
}
 
void affiche_plateau (SDL_Surface *ecran, Plateau *plateau)
{
    SDL_Rect positionBoule;
    SDL_Rect positionMur;
    int i, j, k, l;
    int NB_BLOCS_LARGEUR;
    int NB_BLOCS_HAUTEUR;
 
    NB_BLOCS_LARGEUR = plateau->tabX;
    NB_BLOCS_HAUTEUR = plateau->tabY;
 
 
 
        /** Téléchargement de l'image de fond **/
 
        /*Chargement de l'image de fond */
        SDL_Surface* bmp_image = IMG_Load("data/4.png");
        if (!bmp_image)
        {
            printf("Erreur de chargement du bitmap: %s\n", SDL_GetError());
            return 1;
        }
 
        /* Positions de l'image sur l'ecran */
        SDL_Rect position;
 
        position.x = 0;
        position.y = 0;
 
        /* Dessine image sur l'ecran */
        SDL_BlitSurface(bmp_image, NULL, ecran, &position);
        SDL_Flip(ecran);
 
 
 
        /** Chargement des images utilisés par le plateau **/
 
           SDL_Surface *bBleu = IMG_Load("data/boule_bleue.png");
           SDL_Surface *bRouge = IMG_Load("data/boule_rouge.png");
           SDL_Surface *bJaune = IMG_Load("data/boule_jaune.png");
           SDL_Surface *bVerte = IMG_Load("data/boule_verte.png");
           SDL_Surface *bMarine = IMG_Load("data/boule_marine.png");
           SDL_Surface *bOrange = IMG_Load("data/boule_orange.png");
           SDL_Surface *bViolette = IMG_Load("data/boule_violette.png");
           SDL_Surface *bMur = IMG_Load("data/boule_mur.bmp");
           SDL_Surface *mur = IMG_Load("data/mur_violet.png");
 
 
 
        /** Affichage des bordures mur **/
 
 
            for (l = 0 ; l < NB_BLOCS_LARGEUR ; l++)
            {
                positionMur.x = l * TAILLE_BLOC;
                positionMur.y = 0;
                positionBoule.w = mur->w;
                positionBoule.h = mur->h;
                SDL_BlitSurface(mur, NULL, ecran, &positionMur);
            }
 
 
            for (l = 0 ; l < NB_BLOCS_HAUTEUR ; l++)
            {
                positionMur.x = 0 - (0.15 * TAILLE_BLOC);
                positionMur.y = l * TAILLE_BLOC;
                positionBoule.w = mur->w;
                positionBoule.h = mur->h;
                SDL_BlitSurface(mur, NULL, ecran, &positionMur);
            }
 
 
            for (l = 0 ; l < NB_BLOCS_HAUTEUR ; l++)
            {
                positionMur.x = 15 * TAILLE_BLOC - (TAILLE_BLOC * (0.1));
                positionMur.y = l * TAILLE_BLOC;
                positionBoule.w = mur->w;
                positionBoule.h = mur->h;
                SDL_BlitSurface(mur, NULL, ecran, &positionMur);
            }
 
 
            for (l = 0 ; l < NB_BLOCS_HAUTEUR ; l++)
            {
                positionMur.x = l * TAILLE_BLOC;
                positionMur.y = 26 * TAILLE_BLOC;
                positionBoule.w = mur->w;
                positionBoule.h = mur->h;
                SDL_BlitSurface(mur, NULL, ecran, &positionMur);
            }
 
 
 
        /** Définition de la position des boules **/
 
            k = 0;
            for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
            {
                for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
                {
                    if (i%2 == 0)
                    {
                        positionBoule.x = i * TAILLE_BLOC - (TAILLE_BLOC * (0.00275 * k));
                        positionBoule.y = j * TAILLE_BLOC;
                        k++;
                    }
                    else
                    {
                        positionBoule.x = i * TAILLE_BLOC - (TAILLE_BLOC * (0.00275 * k));
                        positionBoule.y = j * TAILLE_BLOC + (TAILLE_BLOC/2);
                        k++;
                    }
 
 
            /** Affichage des boules en fonction des couleurs et des positions définies dans le ficher **/
 
 
                Boule *bouleTampon;
                bouleTampon = getBoule(plateau, i, j);
                if(bouleTampon->couleur == bleu)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bBleu, SDL_SRCCOLORKEY, SDL_MapRGB(bBleu->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bBleu, NULL, ecran, &positionBoule);
                }
                else if(bouleTampon->couleur == jaune)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bJaune, SDL_SRCCOLORKEY, SDL_MapRGB(bJaune->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bJaune, NULL, ecran, &positionBoule);
                }
                else if(bouleTampon->couleur == vert)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bVerte, SDL_SRCCOLORKEY, SDL_MapRGB(bVerte->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bVerte, NULL, ecran, &positionBoule);
                }
                else if(bouleTampon->couleur == violet)
                {
                     /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bViolette, SDL_SRCCOLORKEY, SDL_MapRGB(bViolette->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bViolette, NULL, ecran, &positionBoule);
                }
                else if(bouleTampon->couleur == rouge)
                {
                     /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bRouge, SDL_SRCCOLORKEY, SDL_MapRGB(bRouge->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bRouge, NULL, ecran, &positionBoule);
                }
                else if(bouleTampon->couleur == orange)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bOrange, SDL_SRCCOLORKEY, SDL_MapRGB(bOrange->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bOrange, NULL, ecran, &positionBoule);
                }
                else if(bouleTampon->couleur == marine)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bMarine, SDL_SRCCOLORKEY, SDL_MapRGB(bMarine->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bMarine, NULL, ecran, &positionBoule);
                }
                else if(bouleTampon->couleur == wall)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bMur, SDL_SRCCOLORKEY, SDL_MapRGB(bMur->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bMur, NULL, ecran, &positionBoule);
                }
            }
        }
 
        SDL_Flip(ecran);
 
        affiche_lanceur(ecran,plateau);
 
 
     /** Libération des surfaces chargées **/
        SDL_FreeSurface(bBleu);
        SDL_FreeSurface(bVerte);
        SDL_FreeSurface(bViolette);
        SDL_FreeSurface(bRouge);
        SDL_FreeSurface(bJaune);
        SDL_FreeSurface(bOrange);
        SDL_FreeSurface(bMarine);
        SDL_FreeSurface(bMur);
        SDL_FreeSurface(mur);
 
}
 
 
void affiche_lanceur(SDL_Surface *ecran,  Plateau *plateau)
{
/*
    ecran = SDL_GetVideoSurface();
 
    SDL_Surface* srfTriangle;
 
    SDL_Surface* a_srfRot[N_ROT];
 
 
 
    int done = 0;
 
    CHECK((srfTriangle = IMG_Load("data/fleche.png")), SDL_GetError);
    createRotations(srfTriangle, a_srfRot, N_ROT);
 
    while(!done)
    {
        SDL_Rect rctTmp;
        SDL_Event ev;
        int x, y;
        int angle;
 
        while(SDL_PollEvent(&ev))
        {
            if(ev.type == SDL_QUIT)
            done = 1;
        }
 
        SDL_GetMouseState(&x, &y);
        angle = N_ROT / 2 + ((N_ROT / 2) - 1) *
        atan2((x - 7.84 * TAILLE_BLOC), (y - 25 * TAILLE_BLOC)) / M_PI;
 
        rctTmp.x = (ecran->w - a_srfRot[angle]->w) / 2;
        rctTmp.y = ecran->h - (( a_srfRot[angle]->h /2) + TAILLE_BLOC * 3 / 2);
 
 
        SDL_SetColorKey(a_srfRot[angle], SDL_SRCCOLORKEY, SDL_MapRGB(a_srfRot[angle]->format, 255, 255, 255));
        SDL_BlitSurface(a_srfRot[angle], NULL, ecran, &rctTmp);
 
*/
 
        /** Chargement des images utilisés par le plateau **/
 
           SDL_Surface *bBleu = IMG_Load("data/boule_bleue.png");
           SDL_Surface *bRouge = IMG_Load("data/boule_rouge.png");
           SDL_Surface *bJaune = IMG_Load("data/boule_jaune.png");
           SDL_Surface *bVerte = IMG_Load("data/boule_verte.png");
           SDL_Surface *bMarine = IMG_Load("data/boule_marine.png");
           SDL_Surface *bOrange = IMG_Load("data/boule_orange.png");
           SDL_Surface *bViolette = IMG_Load("data/boule_violette.png");
 
 
            int  niveau;
            niveau = 1;
            Boule *bouleLanceur;
            SDL_Rect positionBouleLanceur;
            bouleLanceur = (Boule*)malloc(sizeof(Boule));
 
            CorrespondanceBoule_Couleur(bouleLanceur, niveau);
            setBoule(plateau, 8, 25, bouleLanceur);
 
            positionBouleLanceur.x = 7.36 * TAILLE_BLOC;
            positionBouleLanceur.y = 25 * TAILLE_BLOC;
 
 
            if(bouleLanceur->couleur == bleu)
            {
                /* On rend le blanc derrière les boules transparent : */
                SDL_SetColorKey(bBleu, SDL_SRCCOLORKEY, SDL_MapRGB(bBleu->format, 255, 255, 255));
                /* On blitte l'image maintenant transparente sur le fond : */
                SDL_BlitSurface(bBleu, NULL, ecran, &positionBouleLanceur);
            }
                else if(bouleLanceur->couleur == jaune)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bJaune, SDL_SRCCOLORKEY, SDL_MapRGB(bJaune->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bJaune, NULL, ecran, &positionBouleLanceur);
                }
                else if(bouleLanceur->couleur == vert)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bVerte, SDL_SRCCOLORKEY, SDL_MapRGB(bVerte->format,  255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bVerte, NULL, ecran, &positionBouleLanceur);
                }
                else if(bouleLanceur->couleur == violet)
                {
                     /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bViolette, SDL_SRCCOLORKEY, SDL_MapRGB(bViolette->format,  255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bViolette, NULL, ecran, &positionBouleLanceur);
                }
                else if(bouleLanceur->couleur == rouge)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bRouge, SDL_SRCCOLORKEY, SDL_MapRGB(bRouge->format, 255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bRouge, NULL, ecran, &positionBouleLanceur);
                }
                else if(bouleLanceur->couleur == orange)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bOrange, SDL_SRCCOLORKEY, SDL_MapRGB(bOrange->format,  255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bOrange, NULL, ecran, &positionBouleLanceur);
                }
                else if(bouleLanceur->couleur == marine)
                {
                    /* On rend le blanc derrière les boules transparent : */
                    SDL_SetColorKey(bMarine, SDL_SRCCOLORKEY, SDL_MapRGB(bMarine->format,  255, 255, 255));
                    /* On blitte l'image maintenant transparente sur le fond : */
                    SDL_BlitSurface(bMarine, NULL, ecran, &positionBouleLanceur);
                }
        SDL_Flip(ecran);
 
 
    /** Libération des surfaces chargées **/
        SDL_FreeSurface(bBleu);
        SDL_FreeSurface(bVerte);
        SDL_FreeSurface(bViolette);
        SDL_FreeSurface(bRouge);
        SDL_FreeSurface(bJaune);
        SDL_FreeSurface(bOrange);
        SDL_FreeSurface(bMarine);
 
    }

J'ai un second dicher plateau.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
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
#ifndef __PLATEAU_C__
#define __PLATEAU_C__
 
 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
 
#include "plateau.h"
 
 
 
Boule * getBoule(const Plateau * plateau, const int x, const int y)
{
    assert((x>=0)&&(y>=0)&&(x<plateau->tabX)&&(y<plateau->tabY));
    return(&plateau->boule[y][x]);
}
 
 
void setBoule(Plateau * plateau, const int x, const int y, const Boule * boule)
{
    assert((x>=0)&&(x<(plateau->tabX)));
    assert((y>=0)&&(y<(plateau->tabY)));
    (plateau->boule[y][x])=*boule;
}
 
 
void liberePlateau(Plateau *plateau)
{
    free(plateau->boule);   /* éviter les fuites de mémoires */
    plateau->tabX = 0;
    plateau->tabY = 0;
}
 
void CorrespondanceBoule_Couleur (Boule *boule, int niveau)
{
    int res = (rand() % (2 + niveau)) + 1;
 
    if(res == 1)
    {
        boule->couleur = jaune;
 
    }
    else if (res == 2)
    {
        boule->couleur = bleu;
    }
    else if(res == 3)
    {
        boule->couleur = rouge;
    }
    else if(res == 4)
    {
        boule->couleur = vert;
    }
    else if(res == 5)
    {
        boule->couleur = violet;
    }
    else if(res == 6)
    {
        boule->couleur = orange;
    }
    else if(res == 7)
    {
        boule->couleur = marine;
    }
    else if(res == 8)
    {
        boule->couleur = noire;
    }
    else if(res == 9)
    {
        boule->couleur = multicouleur;
    }
    else if (res == 10)
    {
        boule->couleur = feu;
    }
}
 
//on considere que les lignes impaires sont decales a droite
BoulePosition* getVoisins(const Plateau * plateau, const int ligne, const int colonne)
{
	BoulePosition voisins[6];
	//lignes paires
	if(ligne % 2 == 0)
	{
		if(colonne > 0)
		{
			if(ligne > 0)
			{
				voisins[0].boule =  plateau->boule[ligne - 1][colonne - 1];
                voisins[0].ligne =  ligne - 1;
				voisins[0].colonne =  colonne - 1;
 
			}
			else
			{
                voisins[1].boule =  plateau->boule[ligne][colonne - 1];
				voisins[1].ligne = ligne - 1;
                voisins[1].colonne = colonne;
			}
			if(ligne + 1 < plateau->tabY)
			{
				voisins[2].boule = plateau->boule[ligne + 1][colonne - 1];
                voisins[2].ligne = ligne - 1;
                voisins[2].colonne = colonne + 1;
            }
 
		}
		if(ligne > 0)
		{
			voisins[3].boule = plateau->boule[ligne - 1][colonne];
            voisins[3].ligne = ligne;
            voisins[3].colonne = colonne - 1;
		}
		if(ligne + 1 < plateau->tabY)
		{
			voisins[4].boule = plateau->boule[ligne + 1][colonne];
            voisins[4].ligne = ligne;
            voisins[4].colonne = colonne + 1;
		}
		if(colonne + 1 < plateau->tabX)
		{
			voisins[5].boule = plateau->boule[ligne][colonne + 1];
            voisins[5].ligne = ligne;
            voisins[5].colonne = colonne + 1;
		}
	return voisins;
	}
 
	//lignes impaires
	else
	{
		if(colonne + 1 < plateau->tabX)
		{
			if(ligne > 0)
			{
				voisins[0].boule = plateau->boule[ligne - 1][colonne + 1];
                voisins[0].ligne = ligne - 1;
                voisins[0].colonne = colonne - 1;
			}
			else
			{
                voisins[1].boule = plateau->boule[ligne][colonne + 1];
                voisins[1].ligne = ligne - 1;
                voisins[1].colonne = colonne;
            }
			if(ligne + 1 < plateau->tabY)
			{
				voisins[2].boule = plateau->boule[ligne + 1][colonne + 1];
                voisins[2].ligne = ligne - 1;
                voisins[2].colonne = colonne + 1;
			}
		}
		if(ligne > 0)
		{
			voisins[3].boule = plateau->boule[ligne - 1][colonne];
            voisins[3].ligne = ligne;
            voisins[3].colonne = colonne - 1;
		}
		if(ligne + 1 < plateau->tabY)
		{
			voisins[4].boule = plateau->boule[ligne + 1][colonne];
            voisins[4].ligne = ligne;
            voisins[4].colonne = colonne + 1;
		}
		if(colonne > 0)
		{
			voisins[5].boule = plateau->boule[ligne][colonne - 1];
            voisins[5].ligne = ligne;
            voisins[5].colonne = colonne + 1;
		}
	}
	return voisins;
}
 
void initPlateau(Plateau *plateau, char nomfic[])
{
    char buffer[1024];
    int k, m, n;
 
    FILE* file;
    file = fopen(nomfic, "r");
    fscanf(file, "%d %d \n", &plateau->tabX, &plateau->tabY);
    plateau->boule=(Boule**)malloc(sizeof(Boule*)*plateau->tabY);
    for (k=0; k<plateau->tabY; k++)
    {
     	plateau->boule[k]=(Boule*)malloc(sizeof(Boule)*plateau->tabX);
    }
 
    Boule bouleBleu;
    bouleBleu.couleur=bleu;
    bouleBleu.etat=fixe;
 
    Boule bouleRouge;
    bouleRouge.couleur=rouge;
    bouleRouge.etat=fixe;
 
    Boule bouleJaune;
    bouleJaune.couleur=jaune;
    bouleJaune.etat=fixe;
 
    Boule bouleVerte;
    bouleVerte.couleur=vert;
    bouleVerte.etat=fixe;
 
    Boule bouleMarine;
    bouleMarine.couleur=marine;
    bouleMarine.etat=fixe;
 
    Boule bouleOrange;
    bouleOrange.couleur=orange;
    bouleOrange.etat=fixe;
 
    Boule bouleViolette;
    bouleViolette.couleur=violet;
    bouleViolette.etat=fixe;
 
    Boule bouleVide;
    bouleVide.couleur=vide;
    bouleVide.etat=fixe;
 
    Boule bouleMur;
    bouleMur.couleur=wall;
    bouleMur.etat=fixe;
 
 
    for (m=0; m<plateau->tabX; m++)
    {
	for (n=0; n<plateau->tabY; n++)
	{
	    setBoule(plateau, m, n, &bouleVide);
	}
    }
 
 
    /* On crée un buffer pour charger le terrain depuis le fichier vers le tableau */
    while (fgets (buffer, 1024, file))
    {
	int x, y;
	char couleur;
	sscanf(buffer, "%d %d %c\n", &x, &y, &couleur);
	if(couleur == 'b')
	{
	   setBoule(plateau, x, y, &bouleBleu);
	}
	else if(couleur == 'r')
	{
	   setBoule(plateau, x, y, &bouleRouge);
	}
	else if(couleur == 'j')
	{
	   setBoule(plateau, x, y, &bouleJaune);
	}
	else if(couleur == 'v')
	{
	   setBoule(plateau, x, y, &bouleVerte);
	}
	else if(couleur == 'm')
	{
        setBoule(plateau, x, y, &bouleMarine);
	}
	else if(couleur == 'p')
	{
	   setBoule(plateau, x, y, &bouleViolette);
	}
	else if(couleur == 'o')
	{
	   setBoule(plateau, x, y, &bouleOrange);
	}
    else if(couleur == 'w')
	{
	   setBoule(plateau, x, y, &bouleMur);
	}
 
     }
 
 
    /* On libère l'espace */
    fclose (file);
    printf ("Sortie init plateau avec succès\n");
}
 
 
 
#endif

Un autre fichier avec un système de gain/perte absolument pas abouti, que je ne peux pas tester de toute façon..

Je peux également vous montrer mon boule.h que je ne sais absolument pas comment remplir au final.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef BOULE_H
#define BOULE_H
 
    typedef enum  {jaune, bleu, rouge, vert, violet, orange, marine, noire, multicouleur, feu, vide, wall} Couleur;
    typedef enum  {fixe, mouvement, attente} Etat;
 
 
typedef struct
{
    Couleur couleur;
    Etat etat;
} Boule;
 
 
/* après un tir de boule, s'il y a 2 ou plus boules voisines de la même couleurs, elles disparaissent, ainsi que toutes les boules qui sont en dessous */
void disparitionBoule(Boule boule);
 
/* une éventuelle animation lors de la disparition des boules */
void animationBoule(Boule boule);
 
 
#endif

Et enfin mon main.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
#include "ecran.h"
#include "plateau.h"
#include <time.h>
 
 
int main ( int argc, char** argv )
{
     srand(time(NULL)) ;
     Plateau plateau;
     SDL_Surface ecran;
 
     initPlateau(&plateau, "data/formeNiv1.txt");
 
     int res = affiche_menu(&ecran, &plateau);
 
     if(res == 1)
	 printf("Erreur dans affiche fond ecran\n");
 
 
 
    return 0;
 
}

Voila, donc comme je vous ai dit, ce code est un peu brouillon; SDL et C sont totalement mélangés, mais je vous avoue que je ne sais absolument pas comment l'organiser.
Je n'arrive donc pas à avancer.
A la compilation, j'ai donc mon menu, lorsque j'appuye sur "1" le plateau s'affiche, avec des boules posés grace au ficher "FormeNiv1.txt", et la boule lanceur s'affiche.

J'aurais aimé qu'en plus de m'afficher la boule du lanceur aléatoirement, je puisse tiré cette dernière aux différents endroit possibles, et que suite à ca, soit la boule se positionne au bon endroit, soit des boules disparaissent. Mais je n'ai absolument aucune idée de comment faire..

De plus (si possible, et si ca ne perturbe pas trop le tout), que tous les 5 tirs (par exemple), la ligne mur que j'ai posé en dessus du plateau descende d'une ligne, afin de compliqué le jeu; et donc d'avoir une ligne "laser" au dessus du lanceur qui, lorsqu'une boule toucherait cette ligne, le jeu serait PERDU. Ainsi, lorsque toutes les boules du plateau auront disparu, le jeu sera évidemment GAGNE.

Si l'un de vous a le temps de regarder un peu mon code brouillon, mais qui je crois fonctionne, je lui serais vraiment reconnaissant.

Merci beaucoup.

Citation:

J'aurais aimé qu'en plus de m'afficher la boule du lanceur aléatoirement, je puisse tiré cette dernière aux différents endroit possibles, et que suite à ca, soit la boule se positionne au bon endroit, soit des boules disparaissent. Mais je n'ai absolument aucune idée de comment faire..

Dans la boucle d'affichage, il faut prévoir à chaque fois d’effacer l'écran et d'afficher les boules qui doivent l'être.
As tu déjà regardé des exemples avec la gestion des trajectoires et des collisions ?

Dans la boucle d'affichage du lanceur ou du plateau?
Non, j'ai cherché comment faire, mais je n'ai absolument rien trouvé..

L'affichage doit se faire dans la boucle principale qui gère les évènements.

Citation:

Non, j'ai cherché comment faire, mais je n'ai absolument rien trouvé..

Google n'est pas ton ami ? ;)
Il y a un tuto sur le site :
XI. Détection et gestion des collisions avec SDL

Oui oui, je suis bien d'accord. Mais avant de gérer les collisions, il faut peut être commencé par le tir de la boule suivant la trajectoire du curseur, non ?

Oui, mais il est important d'avoir une bonne structure de départ.
Je pense par exemple qu'il ne faut qu' un seul SDL_Flip(ecran) et il faut le placer à la fin de ta boucle "while (continuer)".
De même pour la fonction d'affichage : pour l'instant ta fonction d'affichage "affiche_plateau" n'est associée qu'à un seul évènement particulier (demande à jouer).

Oui. Je suis partante pour corriger tout ce qui ne va pas.

Tout a fait, j'avais un bug parce que lorsque je demandais à jouer plusieurs fois ca me chargeait à chaque fois le plateau, et je pense qu'en effet ça vient du SDL_Flip(ecran) que je n'avais pas mis a la fin de ma boucle. Merci!
Oui oui, effectivement, affichage_plateau n'est appelé que lorsqu'on demande à jouer, il ne faut pas?

Merci, en tout cas, de prendre du temps pour m'aider. C'est vraiment gentil.

Citation:

affichage_plateau n'est appelé que lorsqu'on demande à jouer, il ne faut pas?

L'affichage en général pour des mouvements fluides doit se faire périodiquement.
Je te conseille de reprendre la structure pour avoir quelque chose de la sorte :
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 initSDL(); // Chargement des bmp en SDL_surface initPlateau(); while (continuer) { while (SDL_PollEvent(&event)) { switch (event.type) { // les différents case // suivant les évènements : // l'appel de la fonction chargementNiveau(); // l'appel de la fonction Tir(); // ... } } // Effacement de l'écran ou Blit de l'image de fond // Fonction pour actualiser la position de la boule tirée // et Gestion des collisions, des boules à afficher // Affichage des boules (Blit des surfaces) SDL_Flip(ecran); // Gestion d'un délai (fréquence fixe d'affichage) pour conso CPU } // Libérations des surfaces
Pour la trajectoire de la balle tirée il faut gérer sa position et un vecteur vitesse, il faut ensuite déterminer les boules qui restent à afficher en fonction des collisions.

Voila, j'ai un code un peu plus ordonné qui complie bien, maintenant j'aimerai m'occuper du tir de la boule.

Citation:

Envoyé par nanosoft

Pour la trajectoire de la balle tirée il faut gérer sa position et un vecteur vitesse, il faut ensuite déterminer les boules qui restent à afficher en fonction des collisions.

Ouep je suis d'accord ! D'abord, j'ai tenté de faire le lanceur. Mais, je n'arrive pas a gérer la transparance, parce que lorsque la flèche tourne, elle laisse un tracé noir carré autour..

Voici le code :

Dans ecran.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
void createRotations(SDL_Surface *srfSrc, SDL_Surface **a_srfRot, int n)
{
        int i;
        for(i = 0; i < n; i++)
        {
            SDL_Surface* srfTmp = rotozoomSurface(srfSrc, i * 360 / n, 1.0, 1);
            SDL_SetColorKey(srfTmp, SDL_RLEACCEL |SDL_SRCCOLORKEY, 0);
            a_srfRot[i] = SDL_DisplayFormat(srfTmp);
            SDL_FreeSurface(srfTmp), srfTmp = NULL;
        }
}
 
void freeRotations(SDL_Surface **a_srfRot, int n)
{
        int i;
        for(i = 0; i < n; i++)
        SDL_FreeSurface(a_srfRot[i]), a_srfRot[i] = NULL;
}
 
void affiche_bouleLanceur(SDL_Surface *ecran, Plateau *plateau)
{
 
    int niveau;
    niveau = 1;
    Boule *bouleLanceur;
    bouleLanceur = (Boule*)malloc(sizeof(Boule));
 
    CorrespondanceBoule_Couleur(bouleLanceur, niveau);
    setBoule(plateau, 8, 25, bouleLanceur);
 
}
 
void affiche_lanceur(SDL_Surface *ecran, Plateau *plateau)
{
        SDL_Rect rctTmp;
        SDL_Event ev;
        int x, y;
        int angle;
 
        ecran = SDL_GetVideoSurface();
 
        SDL_Surface* srfTriangle;
 
        SDL_Surface* a_srfRot[N_ROT];
 
        int done = 0;
 
        CHECK((srfTriangle = IMG_Load("data/fleche.png")), SDL_GetError);
        createRotations(srfTriangle, a_srfRot, N_ROT);
        affiche_plateau(ecran, plateau);
        affiche_bouleLanceur(ecran, plateau);
 
        while(!done)
        {
            while(SDL_PollEvent(&ev))
            {
                if(ev.type == SDL_QUIT)
                done = 1;
            }
 
        affiche_plateau(ecran, plateau);
 
        SDL_GetMouseState(&x, &y);
        angle = N_ROT / 2 + ((N_ROT / 2) - 1) *
        atan2((x - 7.84 * TAILLE_BLOC), (y - 25 * TAILLE_BLOC)) / M_PI;
 
        rctTmp.x = (ecran->w - a_srfRot[angle]->w) / 2;
        rctTmp.y = ecran->h - (( a_srfRot[angle]->h /2) + TAILLE_BLOC * 3 / 2);
 
        SDL_SetColorKey(a_srfRot[angle], SDL_SRCCOLORKEY, SDL_MapRGB(a_srfRot[angle]->format, 255, 255, 255));
        SDL_BlitSurface(a_srfRot[angle], NULL, ecran, &rctTmp);
 
        SDL_Flip(ecran);
        }
}

Dans ecran.h

Code:

1
2
3
4
5
6
7
8
#include<SDL/SDL_rotozoom.h>
#define N_ROT 360
#define CHECK(cond, fun) \
    do{ \
    if (!(cond)) \
        fprintf(stderr, "%s line : %u\n %s\n", __FILE__, __LINE__, fun()), \
        exit(EXIT_FAILURE); \
    }while(0);

Voila, si vous trouvez un éventuel bug.. Ou si quelqu'un pouvait m'expliquer comment, grace a cette flèche, tirer une boule et la positionner à l'endroit voulu, ce serait vraiment cool.. Parce que j'en ai vraiment aucune idée. :/

Merci beaucoup.

Citation:

lorsque la flèche tourne, elle laisse un tracé noir carré autour..

J'ai l'impression que c'est parce-que tu "blit" les différents angles les uns à la suite des autres sans effacer le précédent !

et puis la fonction affiche_lanceur est bizarre : elle contient une boucle et tu n'en sors qu'avec SDL_QUIT !
As-tu fait cela à des fins de test ?
(Utilise plutôt une fonction de type pause pour visualiser les différents affichages)

Citation:

Voila, j'ai un code un peu plus ordonné

Éventuellement montre nous la structure afin que l'on puisse te guider dans l'agencement des fonctions.

Citation:

si quelqu'un pouvait m'expliquer comment, grâce a cette flèche, tirer une boule et la positionner à l'endroit voulu

L'origine et l'extrémité de la flèche au moment du tir vont te permettre de déterminer la droite que doit suivre la boule. Ensuite il faut incrémenter une variable en fonction du temps (par exemple à chaque tour de boucle) ; faire évoluer les positions x et y de la boule proportionnellement à cette variable (en respectant y/x = pente de la droite).