IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Concurrence et multi-thread Java Discussion :

Threads et affichage fluide


Sujet :

Concurrence et multi-thread Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre à l'essai
    Inscrit en
    Décembre 2009
    Messages
    5
    Détails du profil
    Informations forums :
    Inscription : Décembre 2009
    Messages : 5
    Par défaut Threads et affichage fluide
    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 !

  2. #2
    Expert éminent
    Avatar de tchize_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2007
    Messages
    25 482
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2007
    Messages : 25 482
    Par défaut
    c'est parce que tu manipule ton interface graphique depuis un thread autre que le thread graphique (l'EDT). On ne peux manipuler les interfaces graphiques que depuis l'EDT en swing, sous peine de bugs, de données corrompue ou de problèmes d'affichages. Voir les FAQs swing de ce forum, ça y est très bien expliqué.

Discussions similaires

  1. Threads et Affichage
    Par Clout dans le forum C++Builder
    Réponses: 4
    Dernier message: 02/11/2007, 08h55
  2. [C# 2.0] Thread d'affichage
    Par OtI$ dans le forum Windows Forms
    Réponses: 4
    Dernier message: 07/06/2007, 12h07
  3. [1.1] Comment accéder au thread d'affichage ?
    Par fregolo52 dans le forum Framework .NET
    Réponses: 1
    Dernier message: 20/09/2006, 11h27
  4. [MFC] thread d'affichage
    Par Joeleclems dans le forum MFC
    Réponses: 31
    Dernier message: 23/05/2005, 14h47
  5. Thread et affichage direct3D plein écran
    Par Harry_polin dans le forum DirectX
    Réponses: 8
    Dernier message: 13/03/2003, 22h22

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo