Discussion :

[titio04]

Bonjour,

J'ai créée un Scrabble client serveur qui utilise la technologie socket. J'ai un problème c'est que je ne sais pas comment faire pour que l'on puisse jouer a plus de deux. En effet, les serveur et le client sont les seules a pouvoir joueur entre eux.

Pourriez-vous m'aider?
Cela fait trois semaine que je galère,
SVP help me !!!!


Merci beaucoup



Classe serveur:

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
import java.io.EOFException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
import javax.swing.JFrame;
import javax.swing.JOptionPane;
 
 
public class Serveur 
{
//	------------------------------------------------------------------------
 
	//	Pour le serveur
	static ObjectOutputStream oos = null;
	static ObjectInputStream ois = null;
	static ServerSocket serveur = null;
	static Socket connexion = null;
 
 
 
	public  Serveur()
	//------------------------------------------------------------------------
	/*
	 * Pour gérer les erreur en Java, nous allons utiliser un try/catch afin de savoir si des erreurs sont survenues. 
	 * Nous allons ensuite instancier la classe ServerSocket avec le port sur lequel le serveur va écouter en argument. 
	 * Une boucle infinie va ensuite servir à intercepter les clients qui tentent de se connecter 
	 * puis nous allons instancier la classe Client avec le Socket crée pour ce client. 
	*/
	{
		try 
		{
 
			String sPort = JOptionPane.showInputDialog( 
				new JFrame() , "Le serveur doit ecouter sur quel port ?" , ""+Client.port 
			);
 
			Client.port = 5600;
 
			try 
			{
				Client.port = 	Integer.parseInt(sPort);
			}
 
			catch( NumberFormatException nfe ) 
			{
			}
 
 
			new SocketServeur();
		}
 
		catch( EOFException eofe ) 
		{
			eofe.printStackTrace();
 
		}
 
		catch( IOException ioe ) 
		{
			ioe.printStackTrace();
		}
	}
 
}

classe Envoyerdonnees:

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
import java.io.IOException;
 
 
public class envoyerDonnees implements Runnable {
 
	public  envoyerDonnees( Object objet )
	//------------------------------------------------------------------------
	{
		try {
			if( objet instanceof String ) {
			}
			Serveur.oos.writeObject( objet );
			Serveur.oos.flush();
			InitialiserInterfaceGraphique.jtaMessage.selectAll();
			InitialiserInterfaceGraphique.jtaMessage.requestFocus();
		}
		catch( IOException ioe ) {
			InitialiserInterfaceGraphique.jta.append( "Scrabble > Erreur a l'ecriture de l'objet...\n" );
			InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );		
		}
	}
 
	public void run() {
		// TODO Auto-generated method stub
 
	}
}

classe Client

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
import java.io.EOFException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.lang.Thread;
 
 
import javax.swing.JOptionPane;
 
 
public class Client extends Connexion{
 
//	Pour le client
	static String message = "";
	static String hote = null;
	static Socket client = null;
	static String libelle = "SERVEUR: ";
	static int port = 5600;
	static boolean connecte = false;  //Indique si la connexion socket est ok 
 
//	------------------------------------------------------------------------
	public Client()
	//------------------------------------------------------------------------
	{
		try {
			clientConnecter();
			clientObtenirFlux();
			traiterConnexion();
			clientFermerConnexion();
		}
		catch( EOFException eofe ) {
			InitialiserInterfaceGraphique.jta.append( "Scrabble > Le serveur a interrompu la connexion...\n" );
			InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );		
		}
		catch( IOException ioe ) {
			ioe.printStackTrace();
		}
	}
 
	//------------------------------------------------------------------------
	public void clientConnecter() throws IOException
	//------------------------------------------------------------------------
	{
		InitialiserInterfaceGraphique.jta.append( "Scrabble > Tentative de connexion...\n" );
		hote = JOptionPane.showInputDialog( 
			this , "Adresse IP de l'hote" , hote 
		);
		String sPort = JOptionPane.showInputDialog( 
			this , "Le serveur ecoute sur quel port ?" , ""+port 
		);
		port = 5600;
		try {
			port = 	Integer.parseInt(sPort);
		}
		catch( NumberFormatException nfe ) {
		}
		System.out.println( "Hote: " + hote + " port: " + port );
		client = new Socket( 
			InetAddress.getByName( hote ) , port   //Cette méthode renvoie l'adresse IP du site local d'appel. 
		);
		connecte = true;
		InitialiserInterfaceGraphique.jmiCommencer.setEnabled( true );
		InitialiserInterfaceGraphique.jta.append( 
			"Scrabble > connecte au serveur.\n"
		);
		InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );		
	}
 
//	------------------------------------------------------------------------
	public void clientObtenirFlux() throws IOException
	//------------------------------------------------------------------------
	{
		Serveur.oos = new ObjectOutputStream( client.getOutputStream() );
		Serveur.oos.flush();
		Serveur.ois = new ObjectInputStream( client.getInputStream() );
	}
 
	//------------------------------------------------------------------------
	public void clientFermerConnexion() throws IOException
	//------------------------------------------------------------------------
	{
		InitialiserInterfaceGraphique.jta.append( "Scrabble > Fermeture de la connexion...\n" );
		InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );		
		Serveur.oos.close();
		Serveur.ois.close();
		Serveur.connexion.close();
	}
}

Classe socketServeur:

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
import java.io.EOFException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
 
 
public class SocketServeur extends Connexion{
 
	public  Thread threadFlux;
	public  Thread threadConnexion;
 
	public  SocketServeur () throws IOException
	{
 
		Serveur.serveur = new ServerSocket( Client.port , 100 );
		while( true ) 
		{
			threadConnexion = new Thread ( new attendreConnexion());
			threadConnexion.start();
			threadFlux = new Thread ( new obtenirFlux());
			threadFlux.start();
			String message = "SERVEUR: Connexion reussie...";
			Serveur.oos.writeObject( message );
			Serveur.oos.flush();
			traiterConnexion();
			fermerConnexion();
		}
 
	}
 
 
}

Classe ObtenirFlux

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
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
 
 
public class obtenirFlux implements Runnable  {
//	------------------------------------------------------------------------
	public  obtenirFlux() throws IOException
	//------------------------------------------------------------------------
	{
		Serveur.oos = new ObjectOutputStream( Serveur.connexion.getOutputStream() );
		Serveur.oos.flush();
		Serveur.ois = new ObjectInputStream( Serveur.connexion.getInputStream() );
	}
 
	public void run() {
		// TODO Auto-generated method stub
 
	}
 
}

Classe attendreConnexion

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
import java.io.IOException;
 
 
public class attendreConnexion implements Runnable {
 
 
 
	//	------------------------------------------------------------------------
	public  attendreConnexion() throws IOException
	//------------------------------------------------------------------------
	{
 
		InitialiserInterfaceGraphique.jta.append( "Scrabble > En attente de connexion...\n" );
		Serveur.connexion = Serveur.serveur.accept();
		Client.connecte = true;
		InitialiserInterfaceGraphique.jmiCommencer.setEnabled( true );
		InitialiserInterfaceGraphique.jta.append( 
			"Scrabble > Client connecte.\n" 
		);
		InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
		InitialiserInterfaceGraphique.jtaMessage.setText( "" );
		InitialiserInterfaceGraphique.jtaMessage.requestFocus();
	}
 
	public void run() {
		// TODO Auto-generated method stub
 
	}
 
}

Classe connexion:

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
 
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Calendar;
import java.util.Vector;
 
import javax.swing.JFrame;
import javax.swing.JOptionPane;
 
 
public class Connexion extends JFrame{
 
 
	//	------------------------------------------------------------------------
	public void fermerConnexion() throws IOException
	//------------------------------------------------------------------------
	{
		InitialiserInterfaceGraphique.jta.append( "Scrabble > L'utilisateur a ferme la connexion...\n" );
		InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );		
		Serveur.oos.close();
		Serveur.ois.close();
		Serveur.connexion.close();
	}
 
 
 
	//	------------------------------------------------------------------------
	public void traiterConnexion() throws IOException
	//------------------------------------------------------------------------
	{	
		do {
			try {
				Object objet = Serveur.ois.readObject();
				if( objet instanceof String ) {
					if( ((String) objet).indexOf( "pseudo:" ) != -1 ) {
					}
				}
				else if( objet instanceof Message ) {
					Message m = (Message)objet;
					switch( m.type ) {
						case Message.ACCEPTER : {
							if( InitialiserInterfaceGraphique.nbLettresRestantes>0 ) 
								InitialiserInterfaceGraphique.planchette.setPeutPiocher( true );
							InitialiserInterfaceGraphique.mesPoints += m.points;
							InitialiserInterfaceGraphique.jtfMoi.setText( "" + InitialiserInterfaceGraphique.mesPoints );
							InitialiserInterfaceGraphique.jtaHisto.append( 
								InitialiserInterfaceGraphique.format( InitialiserInterfaceGraphique.pseudonymeMoi , 10 ) + " : " 
							);
							InitialiserInterfaceGraphique.mots = (Vector) m.objet;
							String chaine = "";
							for( int i=0 ; i<InitialiserInterfaceGraphique.mots.size() ; i++ ) {
								chaine += (String)(InitialiserInterfaceGraphique.mots.get(i)) + 
								( i<InitialiserInterfaceGraphique.mots.size()-1 ? "," : "" );
							}
							InitialiserInterfaceGraphique.jtaHisto.append( InitialiserInterfaceGraphique.format( chaine , 22 ) );
							InitialiserInterfaceGraphique.jtaHisto.append(  m.points + " points.\n" ); 			
							InitialiserInterfaceGraphique.jtaHisto.setCaretPosition( InitialiserInterfaceGraphique.jtaHisto.getText().length() );
							Piocher.onPeutPiocher = true;
							InitialiserInterfaceGraphique.planche.brulerlettres();	
							InitialiserInterfaceGraphique.jlblMoi.setClignote( false );
							InitialiserInterfaceGraphique.jlblAutre.setClignote( true );
							if( InitialiserInterfaceGraphique.nbLettresRestantes == 0 ) {
								new envoyerDonnees(
									new Message(
										Message.PARTIE_ACHEVE ,
										"" ,
										InitialiserInterfaceGraphique.planchette.getNblettres()
									)
								);
							}
							break;						
						}
						case Message.COMMENCER : {
							InitialiserInterfaceGraphique.partieCommentee = true;
							InitialiserInterfaceGraphique.jmiCommencer.setEnabled( false );		
							InitialiserInterfaceGraphique.jmiFin.setEnabled( true );		
							InitialiserInterfaceGraphique.planchette.setPeutPiocher( true );
							InitialiserInterfaceGraphique.jbtnAccepter.setEnabled( false );
							InitialiserInterfaceGraphique.jbtnSoumettre.setEnabled( true );							
							InitialiserInterfaceGraphique.jta.append( 
								"Scrabble > La partie est commencee.\n"
								+"Scrabble > C'est a vous de jouer.\n"
							);	
							InitialiserInterfaceGraphique.jmiChanger.setEnabled( true );			
							InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							InitialiserInterfaceGraphique.jlblMoi.setClignote( true );
							InitialiserInterfaceGraphique.jlblAutre.setClignote( false );
							InitialiserInterfaceGraphique.pseudonymeMoi = JOptionPane.showInputDialog( 
								this , "Veuillez vous choisir un pseudonyme:" , "Moi" 
							);
							InitialiserInterfaceGraphique.jlblMoi.setText( InitialiserInterfaceGraphique.pseudonymeMoi );
							new envoyerDonnees( 
								new Message( Message.CHANGER_PSEUDO , InitialiserInterfaceGraphique.pseudonymeMoi , 0 )
							);	
							InitialiserInterfaceGraphique.debut = Calendar.getInstance().getTimeInMillis();					
							break;
						}
						case Message.REJETER : {
							InitialiserInterfaceGraphique.jta.append( 
									InitialiserInterfaceGraphique.pseudonymeAutre + " > Desole, mot rejete"  
								+ "\n" 
							);
							InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							Vector vecteur = InitialiserInterfaceGraphique.planche.getVecteur();
							InitialiserInterfaceGraphique.planche.setVecteur( new Vector() );
							while( vecteur.size()>0 ) {
								Lettre lettre = (Lettre) vecteur.remove( 
									vecteur.size()-1 
								);
								InitialiserInterfaceGraphique.grille[lettre.rangee][lettre.colonne] = null;
								InitialiserInterfaceGraphique.planchette.ajouterlettre( lettre.n );	
							}
							InitialiserInterfaceGraphique.jbtnSoumettre.setEnabled( true );							
							InitialiserInterfaceGraphique.planchette.repaint();
							if( InitialiserInterfaceGraphique.nbLettresRestantes > 6 ) {
								InitialiserInterfaceGraphique.jmiChanger.setEnabled( true );
							}	
							InitialiserInterfaceGraphique.debut = Calendar.getInstance().getTimeInMillis();			
							break;
						}
						case Message.CHANGER_PSEUDO : {
							String temp = InitialiserInterfaceGraphique.pseudonymeAutre;
							InitialiserInterfaceGraphique.pseudonymeAutre = m.message;
							InitialiserInterfaceGraphique.jlblAutre.setText( InitialiserInterfaceGraphique.pseudonymeAutre );
							InitialiserInterfaceGraphique.jta.append( 
								"Scrabble > " + temp + " devient " 
								+ InitialiserInterfaceGraphique.pseudonymeAutre + "\n" 
							);
							InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							break;
						}
						case Message.TEXTE : {
							InitialiserInterfaceGraphique.jta.append( 
									InitialiserInterfaceGraphique.pseudonymeAutre + " > " + m.message + "\n" 
							);
							InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							//jta.selectAll();
							InitialiserInterfaceGraphique.jtp.clignote( true );
							//jta.requestFocus();
							break;
						}
						case Message.PIOCHER : {
							InitialiserInterfaceGraphique.jta.append( 
								"Scrabble > Il reste " + m.points 
								+ " lettre" + ( m.points>1 ? "s" : "" )
								+ "\n" 
							);
							InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							break;
						}
						case Message.FIN : {
							InitialiserInterfaceGraphique.partieCommentee = false;
							new Sauvegarde();
							break;
						}
						case Message.TEMPS : {
							InitialiserInterfaceGraphique.sonTemps = m.message;
							InitialiserInterfaceGraphique.jtfTempsAutre.setText( InitialiserInterfaceGraphique.sonTemps );
							break;
						}
						case Message.PARTIE_ACHEVE : {
							if( m.points == 0 ) {
								int pen = InitialiserInterfaceGraphique.planchette.getPoints();
								InitialiserInterfaceGraphique.jta.append( 
									"Scrabble > " + InitialiserInterfaceGraphique.pseudonymeAutre + 
									" a termine.  Vous lui transferez " + 
									pen + " point" + 
									(pen>1 ? "s" : "" ) +
									"...\n" 
								);
								InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
								new envoyerDonnees(
									new Message(
										Message.PENALITE , 
										"" , 
										pen
									)
								);
								InitialiserInterfaceGraphique.partieCommentee = false;
								InitialiserInterfaceGraphique.mesPoints -= pen;
								InitialiserInterfaceGraphique.sesPoints += pen;
								InitialiserInterfaceGraphique.jtfMoi.setText( "" + InitialiserInterfaceGraphique.mesPoints );
								InitialiserInterfaceGraphique.jtfAutre.setText( "" + InitialiserInterfaceGraphique.sesPoints );
								InitialiserInterfaceGraphique.jtaHisto.append( 
										InitialiserInterfaceGraphique.format( InitialiserInterfaceGraphique.pseudonymeMoi , 10 ) + " : -" + pen + " points\n" 
								);
								InitialiserInterfaceGraphique.jtaHisto.append( 
										InitialiserInterfaceGraphique.format( InitialiserInterfaceGraphique.pseudonymeAutre , 10 ) + " : +" + pen + " points\n" 
								);
								new Sauvegarde();
								new Partie();																
							}
							else {
								InitialiserInterfaceGraphique.jta.append( 
									"Scrabble > Il ne reste que " + m.points 
									+ " lettre" + ( m.points>1 ? "s" : "" )
									+ " Le " + InitialiserInterfaceGraphique.pseudonymeAutre + "\n" 
								);
								InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							}
							break;
						}
						case Message.PENALITE : {
							InitialiserInterfaceGraphique.jta.append( 
								"Scrabble > Vous avez termine. " + 
								InitialiserInterfaceGraphique.pseudonymeAutre + 
								" vous a transfere " + 
								m.points + " point" + 
								(m.points>1 ? "s" : "" ) +
								"...\n" 
							);
							InitialiserInterfaceGraphique.mesPoints += m.points;
							InitialiserInterfaceGraphique.sesPoints -= m.points;
							InitialiserInterfaceGraphique.jtfMoi.setText( "" + InitialiserInterfaceGraphique.mesPoints );
							InitialiserInterfaceGraphique.jtfAutre.setText( "" + InitialiserInterfaceGraphique.sesPoints );
							InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							InitialiserInterfaceGraphique.partieCommentee = false;
							InitialiserInterfaceGraphique.jtaHisto.append( 
								InitialiserInterfaceGraphique.format( InitialiserInterfaceGraphique.pseudonymeMoi , 10 ) + " : +" + m.points + " points\n" 
							);
							InitialiserInterfaceGraphique.jtaHisto.append( 
								InitialiserInterfaceGraphique.format( InitialiserInterfaceGraphique.pseudonymeAutre , 10 ) + " : -" + m.points + " points\n" 
							);
							new Sauvegarde();
							new Partie();																
							break;
						}
						case Message.QUITTER : {
							InitialiserInterfaceGraphique.jta.append( 
								"Scrabble > Votre adversaire s'est deconnecte...\n"
							);
							InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							JOptionPane.showMessageDialog( 
								this, "Votre adversaire s'est deconnecte..." 
							);
							if( InitialiserInterfaceGraphique.partieCommentee ) {
								new Sauvegarde();																
							}
							InitialiserInterfaceGraphique.partieCommentee = false;
							break;
						}
						case Message.PASSER : {
							InitialiserInterfaceGraphique.jta.append( 
								"Scrabble > L'autre joueur a echange " + m.points + " lettres...\n"
							);
							InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
							InitialiserInterfaceGraphique.jbtnAccepter.setEnabled( true );
							InitialiserInterfaceGraphique.jbtnRetirer.setEnabled( true );
							break;
						}
					}
				}
				else if( objet instanceof Integer ){
					int n = ((Integer) objet).intValue();
					InitialiserInterfaceGraphique.frequence[ n ]--;
					for( int i=0 ; i<InitialiserInterfaceGraphique.nbLettresRestantes ; i++ ) {
						if( InitialiserInterfaceGraphique.lettre[i] == n ) {
							int temp = InitialiserInterfaceGraphique.lettre[i];
							InitialiserInterfaceGraphique.lettre[i] = InitialiserInterfaceGraphique.lettre[InitialiserInterfaceGraphique.nbLettresRestantes-1];
							InitialiserInterfaceGraphique.lettre[InitialiserInterfaceGraphique.nbLettresRestantes-1] = temp;
						}
					}
					InitialiserInterfaceGraphique.nbLettresRestantes--;
				}
				else if( objet instanceof Vector ) {
					Vector v = (Vector) objet;
					InitialiserInterfaceGraphique.planche.setVecteur( v );
					for( int i=0 ; i<v.size() ; i++ ) {
						Lettre lettre = (Lettre) v.get(i);
						InitialiserInterfaceGraphique.grille[lettre.rangee][lettre.colonne] = lettre;
					}
					InitialiserInterfaceGraphique.jbtnAccepter.setEnabled( true );
					InitialiserInterfaceGraphique.debut = Calendar.getInstance().getTimeInMillis();					
					if( v.size() == 0 ) {
						InitialiserInterfaceGraphique.jta.append( 
							"Scrabble > " + InitialiserInterfaceGraphique.pseudonymeAutre + 
							" passe son tour...\n" 
						);
						InitialiserInterfaceGraphique.jbtnRetirer.setEnabled( false );
					}
					else {
						InitialiserInterfaceGraphique.jbtnRetirer.setEnabled( true );
					}
 
					InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
				}
				else {
					InitialiserInterfaceGraphique.planche.setlettre( (Lettre) objet );
					InitialiserInterfaceGraphique.jbtnAccepter.setEnabled( true );
				}
			}
			catch( ClassNotFoundException cnfe ) {
				InitialiserInterfaceGraphique.jta.append( "Scrabble > Objet recu de type inconnu...\n" );
				InitialiserInterfaceGraphique.jta.setCaretPosition( InitialiserInterfaceGraphique.jta.getText().length() );
			}
		} while( !Client.message.equals( "CLIENT: Terminer" ) );
	}
 
}

[nouknouk]

salut,

pour l'idée générale:

- la topologie des connexions réseau la plus classique est en 'étoile' avec le serveur au centre. Concrètement, chaque client va se connecter au serveur. Quand un client veut parler à un autre client, ou au serveur, ou même à l'ensemble des autres clients, il communiquera toujours avec une seule entité: le serveur. A charge pour le serveur de relayer le message aux autres clients quand c'est nécessaire.

- ton serveur doit non pas être basé sur la création et l'utilisation d'une seule socket client (classe Socket) mais sur une collection de sockets. Concrètement ça veut dire que ta variable 'connexion' de la classe Serveur va devenir une collection de Sockets (par exemple une HashMap<Socket, ClientInfos> connexions), ClientInfos contenant les données associées au client (son ID dans la partie, son pseudo, ...).

Donc globalement:

* côté serveur, tu auras: une instance de ServerSocket qui écoutera sur un port ; chaque fois qu'un client se connecte il créé l'instance de Socket qui représentera le canal de communication avec le client. et la stocke dans la map 'connexions'.

* côté client, chacun aura (comme actuellement) une unique instance de Socket qui représentera sa connexion au serveur.

Question threads, si on part sur le principe de l'utilisation 'classique' des sockets (ie. pas de NIO), comme les sockets fonctionnent sur un principe d'appels de fonctions bloquantes, on a:

* côté serveur: un thread pour l'instance de ServerSocket qui attend les connexions des clients + un thread par client connecté pour attendre les données envoyées par le client.

* côté client: un thread pour attendre les données envoyées par le serveur + les autres threads pour exécuter la logique de jeu et gérer l'IHM (typiquement l'EDT de swing, comme pour n'importe quelle autre application graphique 'classique').

[darrylsite]

J'ai moi aussi construit un jeu de dame sur cette topologie. Et c'est aussi celle que j'allais te proposer. Une des avantage j'ai trouvé par la suite est que ça le jeu marche meme si les clients se trouvent derriere des routeurs, comme ça, ils n'auront pas à rediriger et à reserver des ports du routeur pour les besions du jeu. La seule configuration concernera le serveur qui attendra les connexion clientes.

[titio04]

Merci beaucoup,

Je vais regarder comment il fonctionne et essaie de le mettre en place.