Bonjour,

Je fais un projet pour ma formation. C'est un jeu qui consiste à faire un maximum de points en alignant 3 boules ou plus d'une grille. Pas de soucis, mon jeu marche sans problèmes d'affichage visuel.
Cependant, lorsque j'ajoute un thread pour faire une pause (qui puisse être vue par l'œil) entre deux étapes, le temps d'affichage nécessaire juste après le thread est plus important et on voit donc s'afficher les éléments les uns après les autres. Même si c'est très rapide, c'est visible et pas très esthétique.

Donc j'ai essayé pas mal de choses mais rien n'a vraiment marché...

je vous donne les deux classes conernées :

Voici la classe ou se passe le jeu et ou il y a un problème d'afichage :

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
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;
	}
}
et le thread :

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
package jeu;
 
public class TempsPause implements Runnable{
	private AireDeJeu aireDeJeu;
 
	public TempsPause(AireDeJeu aireDeJeu){
		this.aireDeJeu=aireDeJeu;
		new Thread(this).start();
	}
 
	public void run() {
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		aireDeJeu.continuerTraitement();
	}
 
}
Merci d'avance !