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
| package jeu;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JPanel;
public class AireDeJeu extends JPanel implements MouseListener{
private static final int NBCOLONNES=8, NBLIGNES=8; //Classe de traitement du jeu et des boules
private int score;
int nbBoules, nbCombinaisons; //Paramètres pour le calcul du score à chaque action.
private Boule boules[][];
private List<Boule> combinaison;
private Boule boule1, boule2; //Les deux boules échangées
private int ligneEcouteur, colonneEcouteur; //La ligne et la colonne de l'écouteur ou l'on a cliqué
private AireStats aireStats;
boolean partieEnCours; //Indique si on peut échanger des boules ou non .
private GridBagConstraints constraint;
/////////////////CONSTRUCTEURS///////////////////////////////////////////////////////////////////
public AireDeJeu(AireStats aireStats){
aire(aireStats);
}
public void aire(AireStats aireStats){
//initialisation des variables
partieEnCours=true;
this.aireStats=aireStats;
setPreferredSize(new Dimension(450, 450));
setLayout(new GridBagLayout());
constraint= new GridBagConstraints();
score=0;
// Initialisation du tableau des boules.
boules= new Boule[NBLIGNES][NBCOLONNES];
for(int ligne=0; ligne<NBLIGNES; ligne++)
for(int colonne=0; colonne<NBCOLONNES; colonne++)
boules[ligne][colonne]=new Boule(ligne, colonne);
combinaison=new ArrayList<Boule>(); //On initialise la liste des combinaisons
//On supprime les combinaisons déjà existantes
for(int l=NBLIGNES-1; l>=0; l--)
for(int c=NBCOLONNES-1; c>=0; c--)
combinaison(boules[l][c]);
supprimer();
score=0; //On met le score à zéro pour le début de la partie.
setOpaque(false);
afficher();
}
///////////////////METHODES D AFFICHAGE///////////////////////////////////////////////////////////////
public void afficher(){
removeAll(); //On supprime tous les composants qui étaient présents
//Affichage des boules et mise en place de leurs écouteurs.
for(int ligne=0; ligne<NBLIGNES; ligne++){
constraint.gridy=ligne*2+1;
for(int colonne=0; colonne<NBCOLONNES; colonne++){
constraint.gridx=colonne*2+1;
add(boules[ligne][colonne], constraint);
}
}
//mise en place des écouteurs entre les boules.
EntreBoules entre;
for(int ligne=1; ligne<NBLIGNES*2; ligne++){
constraint.gridy=ligne;
if(ligne%2==1)
for(int colonne=2; colonne<NBCOLONNES*2; colonne+=2){
constraint.gridx=colonne;
entre=new EntreBoules(ligne, colonne);
entre.addMouseListener(this);
add(entre, constraint);
}
else for(int colonne=1; colonne<NBLIGNES*2; colonne+=2){
constraint.gridx=colonne;
entre=new EntreBoules(ligne, colonne);
entre.addMouseListener(this);
add(entre, constraint);
}
validate(); //On affiche la nouvelle disposition des boules
}
}
public void paintComponent(Graphics g){
//On entoure l'aire de jeu par un cadre et on met la transparence
super.paintComponent(g);
setOpaque(false);
g.drawLine(0, 0, this.getWidth(), 0);
g.drawLine(0, 0, 0, this.getHeight());
g.drawLine(0, this.getHeight()-1, this.getWidth()-1, this.getHeight()-1);
g.drawLine(this.getWidth()-1, 0, this.getWidth()-1, this.getHeight()-1);
}
/////////////////////////GESTION EVENEMENTS////////////////////////////////////////////////////////////////////////////////
public void mousePressed(MouseEvent e) {
if(e.getSource() instanceof EntreBoules && partieEnCours){ //Si le joueur a cliqué entre deux boules et que la partie n'est pas terminée
EntreBoules ecouteur=(EntreBoules) e.getSource();
ligneEcouteur=ecouteur.getLigne();
colonneEcouteur=ecouteur.getColonne();
nbBoules=0; //On initialise les paramètres de calcul du score au début du tour
nbCombinaisons=0;
combinaison=new ArrayList<Boule>(); //On réinitialise la liste des combinaisons pour cet échange
if(ligneEcouteur%2==0){ //On les intervertit
boule1=boules[ligneEcouteur/2-1][colonneEcouteur/2];
boule2=boules[ligneEcouteur/2][colonneEcouteur/2];
deplacer(boule1, ligneEcouteur/2, colonneEcouteur/2);
deplacer(boule2, ligneEcouteur/2-1, colonneEcouteur/2);
}
else{
boule1=boules[ligneEcouteur/2][colonneEcouteur/2-1];
boule2=boules[ligneEcouteur/2][colonneEcouteur/2];
deplacer(boule1, ligneEcouteur/2, colonneEcouteur/2);
deplacer(boule2, ligneEcouteur/2, colonneEcouteur/2-1);
}
afficher();
bloquerPartie(); //On empeche le joueur d'échanger d'autres boules pendant l'affichage des combiniasons
new TempsPause(this); // On affiche un petit moment l'action avant de continuer
}
}
public void continuerTraitement() {
combinaison(boule1); //On regarde si l'échange a crée des combinaisons
combinaison(boule2);
if(combinaison.size()>0){//S'il y a une combinaison, on supprime
supprimer();
}
else{ //Sinon, on ré-échange les boules pour les remettre a leur place d'origine.
if(ligneEcouteur%2==0){ //On les remet dans les positions initiales
deplacer(boule1, ligneEcouteur/2-1, colonneEcouteur/2);
deplacer(boule2, ligneEcouteur/2, colonneEcouteur/2);
}
else{
deplacer(boule1, ligneEcouteur/2, colonneEcouteur/2-1);
deplacer(boule2, ligneEcouteur/2, colonneEcouteur/2);
}
}
//A la fin du tour, on calcule le nombre de points obtenus et on l'ajoute au score.
score+=nbBoules*nbCombinaisons;
aireStats.afficher(score, nbBoules, nbCombinaisons);//On affiche les différents paramètres voulus
afficher();
reprendrePartie();
}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
/////////////////////////////OPERATIONS SUR LES BOULES////////////////////////////////////////////////////////////////////////
public void deplacer(Boule boule, int ligne, int colonne){ //Déplace une boule à la ligne et à la colonne indiquée.
boules[ligne][colonne]=boule; //On déplace la boule dans le tableau
boule.setLigne(ligne); //Et on modifier ces références
boule.setColonne(colonne);
}
public void combinaison(Boule boule){ //Détecte les différentes combinaisons à partir d'une boule.
int ligne=boule.getLigne(), colonne=boule.getColonne();
int combinaisonAvant=combinaison.size(), combinaisonEntre;
// Combinaisons verticales
if(ligne-1>=0 && comparer(boule, boules[ligne-1][colonne])){ //Si on ne dépasse pas du champ de jeu, on teste l'alignement des couleurs
if(ligne-2>=0 && comparer(boule, boules[ligne-2][colonne])){//Si on en a trois d'alignés
ajouter(combinaison, boules[ligne-1][colonne]);
ajouter(combinaison, boules[ligne-2][colonne]);//On les ajoute comme combinaison
for(int i=ligne-3; i>=0; i--)
if(comparer(boule, boules[i][colonne])) //Et on regarde s'il n'y a pas de combinaison de plus de trois dans cette direction
ajouter(combinaison, boules[i][colonne]);
else break;
}
if(ligne+1<8 && comparer(boule, boules[ligne+1][colonne])){
ajouter(combinaison, boules[ligne-1][colonne]);
ajouter(combinaison, boules[ligne+1][colonne]);
}
}
if(ligne+1<8 && comparer(boule, boules[ligne+1][colonne])){
if(ligne+2<8 && comparer(boule, boules[ligne+2][colonne])){
ajouter(combinaison, boules[ligne+1][colonne]);
ajouter(combinaison, boules[ligne+2][colonne]);
for(int i=ligne+3; i<8; i++)
if(comparer(boule, boules[i][colonne]))
ajouter(combinaison, boules[i][colonne]);
else break;
}
}
if(combinaison.size()>combinaisonAvant)
nbCombinaisons++;//On ajoute une combinaison pour le calcul du score.
combinaisonEntre=combinaison.size();
//Combnaisons horizontales
if(colonne-1>=0 && comparer(boule, boules[ligne][colonne-1])){
if(colonne-2>=0 && comparer(boule, boules[ligne][colonne-2])){
ajouter(combinaison, boules[ligne][colonne-1]);
ajouter(combinaison, boules[ligne][colonne-2]);
for(int i=colonne-3; i>=0; i--)
if(comparer(boule, boules[ligne][i]))
ajouter(combinaison, boules[ligne][i]);
else break;
}
if(colonne+1<8 && comparer(boule, boules[ligne][colonne+1])){
ajouter(combinaison, boules[ligne][colonne-1]);
ajouter(combinaison, boules[ligne][colonne+1]);
}
}
if(colonne+1<8 && comparer(boule, boules[ligne][colonne+1])){
if(colonne+2<8 && comparer(boule, boules[ligne][colonne+2])){
ajouter(combinaison, boules[ligne][colonne+1]);
ajouter(combinaison, boules[ligne][colonne+2]);
for(int i=colonne+3; i<8; i++)
if(comparer(boule, boules[ligne][i]))
ajouter(combinaison, boules[ligne][i]);
else break;
}
}
if(combinaison.size()>combinaisonEntre)
nbCombinaisons++;//On ajoute une combinaison pour le calcul du score.
if(combinaison.size()>combinaisonAvant){
ajouter(combinaison, boule); //Si il y a une (ou plusieurs) combinaisons, on ajoute la boule d'origine
}
}
public boolean comparer(Boule bouleOrigine, Boule boule){ //renvoie si la couleur est la même entre lesdeux boules, ou pas.
if(bouleOrigine.getCouleur().equals(boule.getCouleur()))
return true;
else return false;
}
public void ajouter(List<Boule> liste, Boule boule){ //On ajoute la boule dans la liste demandée si elle n'y est pas déjà
boolean dansListe=false;
for(Boule bouleTmp:liste)
if(bouleTmp==boule)
dansListe=true;
if(dansListe==false)
liste.add(boule);
}
public void supprimer(){ //On supprime les combinaisons
int ligne;
int colonne;
List<Boule> repercution=new ArrayList<Boule>();
for(Boule boule : combinaison){
ligne=boule.getLigne();
colonne=boule.getColonne();
while(ligne>0){ //Tant qu'on peut, on fait descendre les boules.
deplacer(boules[ligne-1][colonne], ligne, colonne);
ajouter(repercution, boules[ligne][colonne]); //En réorganisant les boules, on récupère celles qu'on déplace pour les tester.
ligne--;
}
boules[ligne][colonne]=new Boule(ligne, colonne); //Puis on fait apparaitre une boule en haut.
ajouter(repercution, boules[ligne][colonne]);
}
nbBoules+=combinaison.size();//On ajoute le nombre de boules de cette étape pour le score.
combinaison=new ArrayList<Boule>(); //On réinitialise les combinaison qui ont étés traitées.
for(Boule boule : repercution) //On regarde si le déplacement des boule a provoqué de nouvelles combinaisons.
combinaison(boule);
if(combinaison.size()>0) //Si c'est le cas, on réajuste les boules.
supprimer();
}
public void bloquerPartie() {
partieEnCours=false;
}
public void reprendrePartie() {
partieEnCours=true;
}
public int getScore() {
return score;
}
public int getNbBoules() {
return nbBoules;
}
public int getNbCombinaisons() {
return nbCombinaisons;
}
} |
