Discussion :

[Zyxcel314]

Bonjour,

Dans mon projet consistant à réaliser un puissance 4, je commence à développer la possibilité de jouer en réseau.
Pour cela j'ai utiliser le Socket de Java dans une classe Client et Serveur :

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
 
package sample;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Server extends Network{
    private ServerSocket ss;
    private Socket clientSocket;
    private ObjectOutputStream oos;
    private Inet adr;
 
    GameController gameController;
 
    public Server(GameController gameController) {
        this.gameController = gameController;
    }
 
    public void host(){
        try {
            ss = new ServerSocket(8080);
            System.out.println("J'attends qu'un client se connecte");
            clientSocket = ss.accept();
            this.gameController.etatNetwork.setText("Connecté");
            System.out.println("Un client s'est connecté");
            gameController.jeu.getChildren().clear();
            gameController.jeu.getChildren().add(new P4_network(gameController, true, this));
            gameController.jeu.setDisable(false);
            System.out.println("P4 ++");
        }
        catch(IOException e) {
            System.out.println("Oops, la création du serveur plante");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
 
    public String getAdresse() {
        return adr.getAdresse();
    }
 
    public int readToken() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(clientSocket.getInputStream());
        int token = (Integer) ois.readObject();
        return token;
    }
 
    public void placeToken(int i) throws IOException {
        oos = new ObjectOutputStream(clientSocket.getOutputStream());
        oos.writeObject(i);
    }
 
 
    /** Closes the connection */
    void closeSocket() {
 
        try {
            this.clientSocket.close();
            ss.close();
        }
        catch (IOException e) {
            System.out.println("Erreur lors de la fermeture des sockets");
        }
 
    }
 
}

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
 
package sample;
import java.io.*;
import java.net.*;
import java.util.*;
 
public class Client extends Network {
    static final Scanner input = new Scanner(System.in);
 
    Socket serverSocket;
    ObjectOutputStream oos;
    private GameController gameController;
 
    /** Creates a new instance of Client */
    public Client(GameController gameController) {
        this.gameController = gameController;
    }
 
 
    public void join(String stringIP) {
        System.out.println("Quelle est l'adresse du server ?");
        try {
            serverSocket = new Socket(stringIP, 8080);
            this.gameController.etatNetwork.setText("Connecté");
            gameController.jeu.getChildren().clear();
            gameController.jeu.getChildren().add(new P4_network(gameController, false, this));
            gameController.jeu.setDisable(false);
            System.out.println("P4 ++");
        } catch (Exception e) {
            System.out.println("Serveur non trouvé ou erreur lors de la connexion au serveur.");
            System.out.println("Vérifiez que celui-ci existe.");
        }
    }
 
    public int readToken() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(serverSocket.getInputStream());
        int token = (Integer) ois.readObject();
        return token;
    }
 
    public void placeToken(int i) throws IOException {
        oos = new ObjectOutputStream(serverSocket.getOutputStream());
        oos.writeObject(i);
    }
 
 
    /** Closes the connection */
    void closeSocket() {
 
        try {
            serverSocket.close();
        }
        catch (IOException e) {
            System.out.println("Erreur lors de la fermeture des sockets");
        }
 
    }
 
}

Mais voila mon problème: lors que je lance le jeu en réseau, j'appelle toutes les 2 secondes une fonction afin de checker les valeur envoyé par socket afin d'actualiser ma grille de jeu en fonction de ce qu'à jouer l'autre.

fonction

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
 
private void refreshGame() {
        Timeline timeline = new Timeline(new KeyFrame(Duration.seconds(2), e -> {
            if (tourRouge == isMyTurn) {
                disabledClickColumn(false);
            }
            else { // quand l'autre joue
                int c = -1;
                if (!tourRouge) {
                    try {
                        c = network.readToken();
                    } catch (IOException | ClassNotFoundException ex) {
                        ex.printStackTrace();
                    }
                    try {
                        insererJeton(new Jeton(!isMyTurn), c);
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
                changeTour();
            }
        }));
        timeline.setCycleCount(Timeline.INDEFINITE);
        timeline.play();
    }

Seulement, si supposons je joue en colonne "1" (donc le 1 est envoyé sur le socket), à la prochaine boucle de ma fonction, si je fais rien, la fonction va lire le "1" précédement envoyé.

Voila pourquoi j'aimerai savoir comment remmettre à zéro l'inputStream comme lorsque je lance la premiere le programme avant d'envoyer ma première valeur.

[thelvin]

Hello,

ça ne marche pas comme ça. On ne regarde pas "toutes les deux secondes" ce que la socket a à lire.
On lit la socket tout le temps, avec un thread qui en a la charge, et on laisse la lecture bloquer quand la socket n'a rien pour l'instant à dire. Et quand elle dit quelque chose et donc qu'on a lu un truc, on réagit en fonction de ce qu'on a lu.

[Zyxcel314]

Ah ok.

Tu aurais un lien à me passer où il explique ce procédé?