Discussion :

[bobby51]

bonjour a tous
voila je développe un petit jeu en réseau (jeu du yin-yang, pas très connu mais très intéressant)
j'en suis a envoyé mes coups par le réseau, cela marche très bien mais j'ai un probleme au niveau de l'affichage
chaque joueur fait a tour de rôle office de serveur et de client
un coup se passe de cette manière
1) j1 choisi un coup
2)execution du coup chez j1
des labels, des images sont censés changé sur ma vue
3) envoie du coup a l'autre joueur j2
lorsque l'autre joueur recoit le coup on l'execute, la vue est bien mis a jour chez lui
4)attente chez j1 de reception du coup de l'autre joueur
c'est la que ca doit bloquer, tant qu'on n'a pas recu le coup de l'autre joueur la vue ne se met pas a jour, du coup quand on recoit le coup il fait l'affichage du coup qu'on a envoyer puis l'affichage du coup qu'on vient de recevoir

ce que j'ai essayé pour l'instant:
-faire une pause dans le programme pour que la vue ai le temps de se mettre a jour: Thread.sleep(1000);:ne marche pas
-forcer l'affichage de la jframe
majframe.repaint;:marche pas

voila j'ai plus trop de solution

je vous met un peut de code si ca peut vous aider
merci d'avance pour vos réponse

execution graphique du coup:

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
leCoup.executer();
      //on maj le label graphique en se servant de l'attribut imageicon du pion
      if (leCoup.getCasedepart().estvide())
      {
          plateauG.get(getindice(leCoup.getCasedepart())).setIcon(ICtransp);
      }
      else
      {
          plateauG.get(getindice(leCoup.getCasedepart())).setIcon(leCoup.getCasedepart().getpion(leCoup.getCasedepart().getListpion().size()-1).getImage());
      }
      plateauG.get(getindice(leCoup.getCasearrive())).setIcon(leCoup.getCasearrive().getpion(leCoup.getCasearrive().getListpion().size()-1).getImage());
      if (leCoup.getCasedepart().getNumcase()==1)
      {
          pionsJ1.setText(String.valueOf(leCoup.getCasedepart().getListpion().size()) + " pions restant");
      }
      else if (leCoup.getCasedepart().getNumcase()==2)
      {
          pionsJ2.setText(String.valueOf(leCoup.getCasedepart().getListpion().size()) + " pions restant");
      }
      txt_historique.setText(txt_historique.getText() + "\n" +leJoueur.getNom()+" -> pion déplacé de la case "+leCoup.getCasedepart().getNumcase()+" à la case "+leCoup.getCasearrive().getNumcase());
      leJoueur=autrejoueur();
      labelJcourant.setText(leJoueur.getNom()+" A VOUS DE JOUER !");

envoie du coup a l'autre joueur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
                      try
                      {
                          socket = new Socket(leJoueur.getAdresse(), 7776);
                          // construction de flux objets à partir des flux de la socket
                          output = new ObjectOutputStream(socket.getOutputStream());
                          output.writeObject(leCoup);
                      }
                      catch (Exception e)
                      {
                          JOptionPane.showMessageDialog(this, "la liaison est rompu"+e);
                          //fermer la partie
                      }

attente du coup de l'autre joueur

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
labelJcourant.setText("en attente de "+ leJoueur.getNom());
        //on fait une pause pour l'affichage des labels
        //Thread.sleep(10000);
        //this.repai
        //on attend le coup de l'autre joueur
        serverSocket = new ServerSocket(7776);
        //on considère que le joueur a 30s pour jouer
        //voir a mettre un timer de son coté
        serverSocket.setSoTimeout(30000);
        // se met en attente de connexion de la part d'un client distant
        socket = serverSocket.accept();
        // connexion acceptée : récupère les flux objets pour communiquer
        // avec le client qui vient de se connecter
        input = new ObjectInputStream(socket.getInputStream());
        // attente les données venant du client
        leCoup = (coup)input.readObject();

[dinobogan]

Ton architecture est compliquée, tu dois absolument faire le serveur d'un côté et le client de l'autre. Il ne faut pas mélangé, ça va devenir très vite une usine à gaz
Voici une possibilité :
Le client envoie un coup au serveur. Si le serveur valide le coup, alors il envoie sa validation à tous les clients qui peuvent rafraichir leur interface. Tu n'est donc plus obligé de semer du code serveur un peu partout dans le code du client.
Le serveur peut être une application à part ou alors un thread à part lancé à partir de l'interface client.

[bobby51]

je m'en rend compte que ca commence a etre le bordel
mais je ne voit pas comment faire autrement, vu que c'est un jeu qui se joue a deux et a tour de role, pendant que l'un décide de faire son coup, l'autre attend la reception

Le serveur peut être une application à part

pas possible c'est un projet scolaire j'ai des contraintes qui m'empeche de mettre en place cette solution, meme si ce serait la plus simple et la plus propre a mettre en place

ou alors un thread à part lancé à partir de l'interface client

ok mais du coup qui ferait le role du serveur? imaginons que je decide que ce soit j1 qui fasse le role du serveur, j'active un thread qui attend un coup.
Dans l'interface de j1 lorsque je fait un coup, je me l'envoie a moi-meme?
et si je fait un coup chez j2: j'envoie mon coup chez j1, reception par le thread, qui renvoie le coup chez j1 et j2, ce serai donc j1 + j2 qui serait muni de méthode d'attente de coup, puis execution et affichage du coup chez chacune des joueurs. ensuite il faudrai que j1 attende le coup de j2 avant de pouvoir continuer, ca ne solutionne donc pas mon probleme. bref, j'en suis au point de départ mais de facon beaucoup plus compliqué...
la solution de chaque instance de l'appli est a la fois client et serveur n'est certes pas idéale, pas très propre, mais pour ce que je veux faire je pense que c'est le mieux a faire, ces coups sont la seule chose qui transite entre l'application

[dinobogan]

Non, pas du tout. Le serveur à part est la solution à ton problème
Pour le serveur dans une appli à part, OK pour la contrainte projet. Ce sera un thread.
Plaçons-nous du côté utilisateur final. Il lance ton jeu, et choisis de démarrer une partie en réseau. Il va donc cliquer sur un bouton pour être serveur : le thread du serveur démarre. ensuite, il appelle un copain, lui transmet son IP+port et son copain lance aussi ton jeu et rentre l'IP+port serveur. Il ne cliquera donc pas sur le bouton de lancement du serveur.
Maintenant, plaçons-nous côté code. Le serveur est réellement un thread à part du client. Le serveur n'a pas à savoir quel est le client local et quel est le client distant. Le serveur va simplement envoyer un message au client qui doit jouer et un autre message au client qui doit attendre. Le serveur va changer alternativement de client. Le client local se connecte par socket au serveur, comme s'il était distant.
Tu dois simplement créer un protocole simple de communication client-serveur.
Le gros avantage est que tu fais une découpe nette entre le code client et le code serveur et le code devient maintenable. De plus, la connexion entre un client et le serveur reste permanente : le code de communication est simplifié, la connexion socket se fait une et une seule fois.
Je le dis et le répète : tu ne dois pas mélanger le code client et le code serveur
ensuite, on peut imaginer que toutes les règles du jeu sont codées sur le serveur. C'est le serveur qui valide ou non un coup. Le client devient un simple afficheur graphique qui répond aux ordres du serveur.

[Lamarios]

Tu lance avec un des deux joueurs un serveur.

Ensuite tu considère les deux joueurs comme clients.

Le joueur qui a crée le serveur envoi quand même des messages réseaux au server en local .

A chaque fois que quelqu'un joue, il envoie un message au serveur. Le serveur renvoie un message à tous les joueurs avec les données du coup ainsi que le joueur qui doit joueur le prochain coup.

Chaque client reçoit ce message. et adapte son interface en fonction du dit message. Celui qui doit attendre, tu lui bloque l'accès aux fonctions pour faire un tour par exemple

[bobby51]

ca m'a l'air de sacrement complexifier le problème!
en effet mon appli n'est pas a proprement parler une appli client-serveur, ce n'est pas comme si plusieurs joueurs pouvaient joueur ensemble, la c'est clair qu' il faudrait un processus(thread,appli) dédié pour gérer les coups joués et les redistribués, ou si par exemple tous mes traitements seraient fait du coté serveur et que le client ne serait plus qu'un afficheur graphique, ce qui n'est pas le cas non plus.
voila pourquoi je trouve que ca complexifie la communication:
-ma solution
j1 joue
j1 execute et affiche son coup
j1 envoie son coup a j2
j2 recoie le coup
j2 execute et affiche le coup
j2 joue
...
-solution client serveur
j1 joue
j1 envoie son coup au serveur
le serveur renvoie le coup a j1 et j2
j1 recoit le coup
j1 execute et affiche le coup
j2 recoit le coup
j2 execute et affiche le coup
j2 joue
...
dans tous les cas:
-les clients envoie des coups
-les clients recoivent des coups
mais dans la solution client-serveur, les coups transitent par un serveur, qui ne fait rien de special, ce qui fait une étape supplementaire

il est clair que je suis d'accord avec vous pour ce qui concerne les application clients serveurs, mais ce n'est pas vraiment le cas-ici

au passage j'ai réglé le problème pour lequel j'avais posté en mettant la reception du coup dans un thread, ca évite en plus de frizzer l'application qui attend que l'autre joueur joue

[Deaf]

Dès que tu as une communication réseau, tu as forcément une relation de client/serveur. Donc pourquoi vouloir se voiler la face?

Ce que t'as expliqué dinobogan est de loin la meilleure solution. Comme tu ne l'as jamais fait, tu peux avoir l'impression de complexifier les choses, mais en réalité, tout sera plus simple pour toi une fois en place.