[PROJET DUT] jeu same

**bigtyler** · 03/12/2006, 11h56

Salut, voilà j'ai un problème avec mon projet de DUT, je dois réaliser le jeu SAME : http://obligement.free.fr/articles/samegame.php

Mon problème est pour enlever les boules de la même couleur qui sont collées, il n'y a que celle au dessus, au dessous et des 2 côtés de celleoù je clique qui disparaissent!

Voici mon CODE :

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
 
#include <stdlib.h>
#include <stdio.h>
#include "/export/documents/lib/sources/graph.h"
 
#define black CouleurParNom("black")
#define white CouleurParNom("white")
#define red CouleurParNom("red")
#define blue CouleurParNom("blue")
#define green CouleurParNom("green")
 
/*on crée un tableau avec le cadrillage et on place les 3 sortes de boules aléatoirement avec la même chance pour chaque boule de tomber*/
void tableau() {
  int L,H,tab[15][10];
 
  srand(time(NULL));
 
  for (H=0;H<10;H++) {
    for (L=0;L<15;L++) {
      tab[L][H]=rand()%3;
      if (tab[L][H]==0) {
	RemplirArcC(L*40+3,H*40+3,34,34,360,360,blue);
      }
 
      if (tab[L][H]==1) {
	RemplirArcC(L*40+3,H*40+3,34,34,360,360,red);
      }
 
      if (tab[L][H]==2) {
	RemplirArcC(L*40+3,H*40+3,34,34,360,360,green);
      }
 
      DessinerRectangleC(L*40,H*40,40,40,white);
      EcrireTexteC(10,420,"Score : ",white,1);
    }
  }
}
 
/*on crée une fonction qui élimine toutes les boules de la même couleur et à côté de celle où on clic*/
 
  /********************************************/
 /********Le problème vient de ce qui suis*********/
/*******************************************/
void cliquesouris() {
  int a,b,tab[15][10];
 
  while (1) {
    if (SourisCliquee()) {
      a=_X/40;
      b=_Y/40;
 
      RemplirArcC(a*40+3,b*40+3,34,34,360,360,black);
 
      if (tab[a][b]!=tab[a+1][b] &&
	  tab[a][b]!=tab[a][b+1] &&
	  tab[a][b]!=tab[a-1][b] &&
	  tab[a][b]!=tab[a][b-1])
	RemplirArcC(a*40+3,b*40+3,34,34,360,360,white);
 
      else {
 
/*Je test la boule à droite de celle où je clic, si elle est de la même couleur, je supprime*/
	if (tab[a][b]==tab[a+1][b]) {
	  RemplirArcC(a*40+43,b*40+3,34,34,360,360,black);
	}
 
/*Je test la boule au dessus de celle où je clic, si elle est de la même couleur, je supprime*/
	if (tab[a][b]==tab[a][b+1]) {
	  RemplirArcC(a*40+3,b*40+43,34,34,360,360,black);
	}
 
/*Je test la boule à gauche de celle où je clic, si elle est de la même couleur, je supprime*/
	if (tab[a][b]==tab[a-1][b]) {
	  RemplirArcC(a*40-37,b*40+3,34,34,360,360,black);
	}
 
/*Je test la boule au dessous de celle où je clic, si elle est de la même couleur, je supprime*/
	if (tab[a][b]==tab[a][b-1]) {
	  RemplirArcC(a*40+3,b*40-37,34,34,360,360,black);
 
	}
      }
    }
  }
}
 
/*on crée la fenetre, on l'affiche*/
int main() {
 
  InitialiserGraphique();
  extern char *nf;
  nf="SAME";
  CreerFenetre(Maxx()/2-300,Maxy()/2-300,600,500);
  AfficherFenetre();
  EffacerEcran(black);
 
  tableau();
  selection();
  cliquesouris();
  Touche();
  FermerGraphique();
 
  return EXIT_SUCCESS;
}

**sliya** · 03/12/2006, 16h16

Salut.
En fait, il faut que tu fasses une fonction récursive. Par exemple, tu fais une fonction prenant en paramètre les coordonnées d'une boule et une couleur. Si la boule est de la bonne couleur tu la supprime et tu rappelle la fonction pour la même couleur et pour les boules adjacentes. Sinon, tu ne fais rien.

Bonne chance.

Sliya

**Médinoc** · 03/12/2006, 16h28

Tu peux également faire ça en itératif, en "marquant" les boules au début, en plusieurs passes.

Tu marques la première boule, celle cliquée.
À chaque passe, tu marques toute boule située à coté d'une boule marquée de même couleur...

Et quand une passe ne modifie rien, tu sais que tu as marqué toutes les boules adjacentes de même couleur.
Un algorithme "en largeur" déterministe certain de réussir.

**bigtyler** · 06/12/2006, 18h13

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
 
//on crée les tableaux (ils sont initialisé dans une autre fonction)
void cliquesouris(int tabx[TXX],int taby[TYY],int tab[TX+2][TY+2]) {
  int a,b,c,d,cr,ct,dep,indxe=0,indxl=0,indye=0,indyl=0;
 
  while(1) {
//Si la souris clique
    if (SourisCliquee()) {
//on enregistre les coordonnées de la souris dans a et b
      a=_X/40;
      b=_Y/40;
 
//obligé de remplir un cercle noir pour remplacer les boules
      RemplirArcC(a*CASE+2,b*CASE+2,36,36,360,360,NOIR);
 
//si il n'ya aucune boule pareil au tour de celle où on clic, on la met en blanc
      if (tab[a][b]!=tab[a][b-1] &&
	  tab[a][b]!=tab[a+1][b] &&
	  tab[a][b]!=tab[a][b+1] &&
	  tab[a][b]!=tab[a-1][b])
 
	RemplirArcC(a*CASE+2,b*CASE+2,36,36,360,360,BLANC);
 
//si la boule du dessus est de la même couleur, on la remplace par du noir
//les couleurs sont enregistré dans le tableau tab : tab[a][b]
      if (tab[a][b]==tab[a][b-1]) {
//on remplace par un cercle noir
	RemplirArcC(a*CASE+2,b*CASE-38,36,36,360,360,NOIR);
//on intègre les coordonnées en X dans le tableau tabx
	tabx[indxe]=a;
//on intègre les coordonnées en Y dans le tableau taby
	taby[indye]=b-1;
//on indexe de 1 la case des tableaux pour ne pas réenregistrer les prochaine coordonnées par dessus celle existantes!
	indxe++;
	indye++;
 
//indxe : indice d'écritrue en X
//indye : indice d'écriture en Y
 
//on affiche les tableaux et coordonnées pour s'assurer qu'elles sont bonnes
	printf("%d\n",a);
	printf("%d\n",b-1);
 
	for (c=0;c<TXX;c++) {
	  printf("%d ",tabx[c]);
      	}
 
	putchar('\n');
 
	for (d=0;d<TYY;d++) {
	  printf("%d ",taby[d]);
	}
	putchar('\n');
      }
 
//la même chose mais avec la boule de droite
      if (tab[a][b]==tab[a+1][b]) {
	RemplirArcC(a*CASE+42,b*CASE+2,36,36,360,360,NOIR);
	tabx[indxe]=a+1;
	taby[indye]=b;
	indxe++;
	indye++;
 
	printf("%d\n",a+1);
	printf("%d\n",b);
 
	for (c=0;c<TXX;c++) {
	  printf("%d ",tabx[c]);
      	}
 
	putchar('\n');
 
	for (d=0;d<TYY;d++) {
	  printf("%d ",taby[d]);
	}
	putchar('\n');
 
      }
 
//la même chose mais avec la boule de dessous
      if (tab[a][b]==tab[a][b+1]) {
	RemplirArcC(a*CASE+2,b*CASE+42,36,36,360,360,NOIR);
	tabx[indxe]=a;
	taby[indye]=b+1;
	indxe++;
	indye++;
 
	printf("%d\n",a);
	printf("%d\n",b+1);
 
	for (c=0;c<TXX;c++) {
	  printf("%d ",tabx[c]);
      	}
 
	putchar('\n');
 
	for (d=0;d<TYY;d++) {
	  printf("%d ",taby[d]);
	}
	putchar('\n');
 
      }
 
//la même chose mais avec la boule de gauche
      if (tab[a][b]==tab[a-1][b]) {
	RemplirArcC(a*CASE-38,b*CASE+2,36,36,360,360,NOIR);
	tabx[indxe]=a-1;
	taby[indye]=b;
	indxe++;
	indye++;
 
	printf("%d\n",a-1);
	printf("%d\n",b);
 
	for (c=0;c<TXX;c++) {
	  printf("%d ",tabx[c]);
      	}
 
	putchar('\n');
 
	for (d=0;d<TYY;d++) {
	  printf("%d ",taby[d]);
	}
	putchar('\n');
      }
 
 
     //***********************************************************************************
     //***********************************************************************************
 
//on reprend les coordonnées enregistrées et on les lit avec indxl et indyl
//indxl : indice de X en lecture
//indyl : indice de Y en lecture
      if (tab[indxl][indyl]==tab[indxl][indyl-1]) {
//on remplie avec un cercle noir
	RemplirArcC(indxl*CASE+2,indyl*CASE-38,36,36,360,360,NOIR);
//on enregistre les coordonnées de la nouvelle boule (celel du dessus de celle testée, pas de celle cliquée au départ)
	tabx[indxe]=indxl;
	taby[indye]=indyl-1;
//on incrémente l'écriture du tableau en X et Y
	indxe++;
	indye++;
//on incrémente la lecture du tableau en X et Y
	indxl++;
	indyl++;
 
	printf("%d\n",indxl);
	printf("%d\n",indyl-1);
 
	for (c=0;c<TXX;c++) {
	  printf("%d ",tabx[c]);
	}
 
	putchar('\n');
 
	for (d=0;d<TYY;d++) {
	  printf("%d ",taby[d]);
	}
	putchar('\n');
      }
 
 
//pareil mais avec la boule de droite
      if (tab[indxl][indyl]==tab[indxl+1][indyl]) {
	RemplirArcC(a*CASE+42,b*CASE+2,36,36,360,360,NOIR);
	tabx[indxe]=indxl+1;
	taby[indye]=indyl;
	indxe++;
	indye++;
	indxl++;
	indyl++;
 
	printf("%d\n",indxl+1);
	printf("%d\n",indyl);
 
	for (c=0;c<TXX;c++) {
	  printf("%d ",tabx[c]);
	}
 
	putchar('\n');
 
	for (d=0;d<TYY;d++) {
	  printf("%d ",taby[d]);
	}
	putchar('\n');
      }
 
//pareil mais avec la boule de dessous
      if (tab[indxl][indyl]==tab[indxl][indyl+1]) {
	RemplirArcC(a*CASE+2,b*CASE+42,36,36,360,360,NOIR);
	tabx[indxe]=indxl;
	taby[indye]=indyl+1;
	indxe++;
	indye++;
	indxl++;
	indyl++;
 
	printf("%d\n",indxl);
	printf("%d\n",indyl+1);
 
	for (c=0;c<TXX;c++) {
	  printf("%d ",tabx[c]);
	}
 
	putchar('\n');
 
	for (d=0;d<TYY;d++) {
	  printf("%d ",taby[d]);
	}
	putchar('\n');
      }
 
//pareil mais avec la boule de gauche
      if (tab[indxl][indyl]==tab[indxl-1][indyl]) {
	RemplirArcC(a*CASE-38,b*CASE+2,36,36,360,360,NOIR);
	tabx[indxe]=indxl-1;
	taby[indye]=indyl;
	indxe++;
	indye++;
	indxl++;
	indyl++;
 
	printf("%d\n",indxl-1);
	printf("%d\n",indyl);
 
	for (c=0;c<TXX;c++) {
	  printf("%d ",tabx[c]);
	}
 
	putchar('\n');
 
	for (d=0;d<TYY;d++) {
	  printf("%d ",taby[d]);
	}
	putchar('\n');
      }
    }
  }
 
//on réinialise les tableaux quand il a fini d'enlever toutes les boules adjacentes
  for (c=0;c<TXX;c++) {
    tabx[c]=-1;
  }
 
  for (d=0;d<TYY;d++) {
    taby[d]=-1;
  }
 
  for (c=0;c<TXX;c++) {
    printf("%d",tabx[c]);
  }
 
  putchar('\n');
 
  for (d=0;d<TYY;d++) {
    printf("%d",taby[d]);
  }   
}

Voilà, ca marche pour les tests au tour de la boule où je clique, mais pas pour les boules enregistrées dans tabx et taby!

**bigtyler** · 15/12/2006, 19h19

micro_projet.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
 
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
 
#define BLEU CouleurParNom("blue")
#define ROUGE CouleurParNom("red")
#define VERT CouleurParNom("green")
#define NOIR CouleurParNom("black")
#define BLANC CouleurParNom("white")
#define TX 15 //on définie la taille du tableau
#define TY 10 // idem
#define NBC 3 //nombre de couleur
#define CASE 40 //on définie la taille des cases
 
#include "fonctions.c" //on charge fonctions.c qui se trouve plus bas
 
/*Creation du tableau*/
//on met toutes ce qu'il faut charger de fonctions.c
int main (void) {
 
  int coul[TX+2][TY+2],virtuel[TX][TY],virtuel2[TX][TY];
 
  srand (time (NULL));
 
  initableaux(coul);
 
  creergrille(coul,NBC);
  initialisergraphique(TX,TY);
  positionnerboules(coul);
  console(coul);
  cliquesouris(coul,virtuel);
 
  Touche();
  FermerGraphique();
 
  return EXIT_SUCCESS;
}

fonctions.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
 
//on initialise le tableau des couleurs, on initialise à +1, -1 pour que le tour du tableau soit entouré de -1 après avoir mis les boules, comme ca, pas d'erreur avec les boules adjacentes
void initableaux(int coul[TX+2][TY+2]) {
  int l,h;
 
  for (h=-1;h<TY+1;h++) {
    for (l=-1;l<TX+1;l++) {
      coul[l][h]=-1;
    }
  }
}
 
//on l'affiche à la cnsole
void console(int coul[TX+2][TY+2]) {
  int l,h,x,y;
 
  for (h=-1;h<TY+1;h++) {
    for (l=-1;l<TX+1;l++) {
      printf("%d ",coul[l][h]);
    }
    putchar('\n');
  }
  putchar('\n');
}
 
//on créer la grille où il y aura les boules de couleur
void creergrille(int coul[TX+2][TY+2],int nbc) {
  int l,h,x,y;
 
  srand (time(NULL));
 
  for(h=0;h<TY;h++) {
    for(l=0;l<TX;l++) {
//même chance aléatorie pour placer les boules
      coul[l][h]=rand()%nbc;
    }
  }
}
 
//on initialise les fonctions inclu dans la bibliothèque graphique graph.h
void initialisergraphique(int tx,int ty) {
  int l,h,a=0,b=0;
 
  InitialiserGraphique();
  extern char *nf;
  nf="Episy Foly Game";
  CreerFenetre(Maxx()/2-300,Maxy()/2-300,900,400);
  AfficherFenetre();
  EffacerEcran(NOIR);
 
 
  for (h=0;h<=TX;h++) {
    DessinerSegmentC(a,0,a,400,BLANC);
    a+=CASE;
  }
  for (l=0;l<=TY;l++) {
    DessinerSegmentC(0,b,600,b,BLANC);
    b+=CASE;
  }
 
  ChargerImageFond("fond.xpm");
  EcrireTexteC(740,160,"Score : ",BLANC,1);
}
 
//on place les boules
void positionnerboules(int coul[TX+2][TY+2]) {
  int l,h;
 
  for (l=0;l<TX;l++) {
    for (h=0;h<TY;h++) {
      if (coul[l][h]==0)
	RemplirArcC(l*CASE+2,h*CASE+2,36,36,360,360,BLEU);
 
      if (coul[l][h]==1)
	RemplirArcC(l*CASE+2,h*CASE+2,36,36,360,360,ROUGE);
 
      if (coul[l][h]==2)
	RemplirArcC(l*CASE+2,h*CASE+2,36,36,360,360,VERT);
 
      if (coul[l][h]==3)
	RemplirArcC(l*CASE+2,h*CASE+2,36,36,360,360,NOIR);
    }
  }
}
 
//on fait en sorte que les boules tombent quand il n'y en a plus en dessous
void bouge(int coul[TX+2][TY+2]) {
  int l,h;
 
  for (h=0;h<TY;h++) {
    for (l=TX-1;l>=0;l--) {
      if (coul[l][h]==3 && coul[l][h-1]!=-1 && coul[l][h-1]!=3 && coul[l][h]!=0) {
	coul[l][h]=coul[l][h-1];
	coul[l][h-1]=3;
      }
    }
  }
 
//on affiche le tableau des couleurs
  printf("tableau couleurs!\n");
  for (h=0;h<TY;h++) {
    for (l=0;l<TX;l++) {
      printf("%d ",coul[l][h]);
    }
    putchar('\n');
  }
  putchar('\n');
}
 
//on s'occupe de la selection en subrillance et de la supression
void cliquesouris(int coul[TX+2][TY+2],int virtuel[TX][TY]) {
  int a,b,l,h,indice=1,repaire,hh,ll,x=_X,y=_Y,d,e;
 
//tant qu'on ne clique pas, faire ...
  while(!SourisCliquee()) {
//on récupère les coordonnées de la souris dans _X et _Y
    SourisPosition();
 
//ici
    a=_X/CASE;
    b=_Y/CASE;
 
//on initialise le tabelau virtuel à -1, il est identique au tableau des couleurs, il est remplie de -1, et quand la souris selectionne les boules, on met des 1 là où les boules sont sélectionnées
    for (h=0;h<TY;h++) {
      for (l=0;l<TX;l++) {
	virtuel[l][h]=-1;
      }
    }
 
//on affiche le tabelau virtuel
    for (h=0;h<TY;h++) {
      for (l=0;l<TX;l++) {
	printf("%d ",virtuel[l][h]);
      }
      putchar('\n');
    }
    putchar('\n');
 
//si la boule où il y a la souris est seul, ne pas la selectionner
    if (coul[a][b]!=coul[a][b-1] &&
	coul[a][b]!=coul[a+1][b] &&
	coul[a][b]!=coul[a][b+1] &&
	coul[a][b]!=coul[a-1][b] && a>=0 && a<TX && b>=0 && b<TY && coul[l][h]!=3) {
 
      if (coul[a][b]==0)
	RemplirArcC(a*CASE+2,b*CASE+2,36,36,360,360,BLEU);
 
      if (coul[a][b]==1)
	RemplirArcC(a*CASE+2,b*CASE+2,36,36,360,360,ROUGE);
 
      if (coul[a][b]==2)
	RemplirArcC(a*CASE+2,b*CASE+2,36,36,360,360,VERT);
    }
 
//sinon mettre le tableau virtuel à 1 au coordonnées de la souris
    else {
      if (coul[a][b]!=3)
	virtuel[a][b]=1;
    }
 
    indice=1;
 
    while(indice==1) {
 
      indice=0;
 
//on parcour le tableau virtuel
      for(h=0;h<TY;h++) {
	for(l=0;l<TX;l++) {
 
//si il trouve un 1 (la où la souris à sélectionnée), et que la couleur est différente de 3 (NOIR : définie dans la fonction positionnerboules)
	  if(virtuel[l][h]==1 && coul[l][h]!=3) {
 
//faire le test 4 fois
	    for(repaire=1;repaire<=4;repaire++) {
 
//une fois pour la boule du dessus
	      if(repaire==1) {
		hh=h+1;ll=l;
	      }
 
//une fois pour la boule de dessous
	      if(repaire==2) {
		hh=h-1;ll=l;
	      }
 
//une fois pour la boule de droite
	      if(repaire==3) {
		hh=h;ll=l+1;
	      }
 
//une fois pour la boule de gauche
	      if(repaire==4) {
		hh=h;ll=l-1;
	      }
 
//si il n'y a pas de 1 au tour, et que l'on reste dans les limites du tableau, mettre à 1 les boules sélectionnées et augmenter l'indice
	      if(virtuel[ll][hh]!=1 && ll>=0 && hh>=0 && ll<TX && hh<TY && coul[l][h]==coul[ll][hh]) {
 
		virtuel[ll][hh]=1;
		indice=1;
 
	      }
	    }
	  }
	}
      }
    }
 
//on parcour le tableau virtuel, si il trouve des 1 et que la couleur n'est pas NOIR, ni -1 (extérieur du tableau), mettre une boule noir
    for (h=0;h<TY;h++) {
      for (l=0;l<TX;l++ ){
	if (virtuel[l][h]==1 && coul[l][h]!=3 && coul[l][h]!=-1 && l>=0 && l<TX && h>=0 && h<TY && virtuel[l][h]!=-1) {
	  RemplirArcC(l*CASE+2,h*CASE+2,36,36,360,360,BLANC);
	}
      }
    }
 
//on charge la fonction positionnerboules pour remetre la couleur des boules après avoir enlever la souris (au cas ou on ne clique pas, sinon les boules reste sélectionnées même si on enlève la souris)
    positionnerboules(coul);
 
//tant qu'on clic
    while (SourisCliquee()) {
 
//on parcour le tableau virtuel
      for (h=0;h<TY;h++) {
	for (l=0;l<TX;l++) {
 
//si on trouve un 1 et que la couleur n'est pas NOIR
	  if (virtuel[l][h]==1 && coul[a][b]!=3) {
 
//mettre 3 à la place du numéro de la boule
//0 pour bleu
//1 pour rouge
//2 pour vert
	    coul[l][h]=3;
//mettre une boule NOIR
	    RemplirArcC(l*CASE+2,h*CASE+2,36,36,360,360,NOIR);
	  }
	}
      }
    }
 
//appeler la fonction boude pour faire descendre les boules
    bouge(coul);
  }
}

Voilà, mon problème :
Suivant où est al souris, des fois à l'extérieur de la fenêtre, des fois dedans, il s'amuse à me placer des boules rouges à la place du NOIR, même parfois à la place de d'autres boules, il y a plein de petit bug de ce genre!
Aidez moi svp, je dois le rendre jeudi!

Merci d'avance!

[PROJET DUT] jeu same

C

Discussions similaires

Partager

Partager