Bonjour,
Suite à mon sujet dans le forum Design patterns, je viens vous exposer mon problème. Je souhaite réaliser un TicTacToe (pour commencer) en réseau.
En ce qui concerne la partie communication réseau, je vous explique en gros comment j'ai organisé mon programme. Au plus bas niveau, j'ai une classe Endpoint qui est juste une couche au dessus du Socket. Viens ensuite, ma classe Connection.
Côté serveur, j'ai une classe ListenerPort qui encapsule un ServerSocket et est à l'écoute des clients qui tentent de se connecter. Puis, à chaque port correspond un Service qui contient les connexions, s'occupe de l'identification du client (chacun d'eux ayant un ClientID) et instancie un Dialogue avec celui-ci. Le Dialogue prend dans son constructeur un MessageHandler, assigné en fonction du type de service, pour gérer les messages.
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 public class Connection { protected IEndpoint endpoint; public Connection(IEndpoint endpoint) { this.endpoint = endpoint; } public Connection(String hostName, Port port) throws IOException { endpoint = new Endpoint(hostName, port); } public void sendMessage(Message message) throws IOException { byte[] buffer = Protocol.getBuffer(message); endpoint.send(buffer); } public Message getReceivedMessage() throws IOException { byte[] buffer = new byte[Endpoint.RECEIVE_BUFFER_SIZE]; endpoint.receive(buffer); return Protocol.getMessage(buffer); } public void close() { endpoint.close(); } public Port getRemotePort() { return endpoint.getRemotePort(); } }
A chaque type de message, son MessageHandler.
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 public abstract class AbstractMessageHandler { private Type type; private AbstractMessageHandler next; public AbstractMessageHandler(Type type) { this.type = type; } public void handleMessage(Connection connection, Message message) { if (message.getType() == type) { doAction(connection, message); } else if (hasNext()) { next.handleMessage(connection, message); } } public void setNext(AbstractMessageHandler next) { this.next = next; } public void addHandler(AbstractMessageHandler handler) { if (hasNext()) { next.addHandler(handler); } else { setNext(handler); } } protected abstract void doAction(Connection connection, Message message); private boolean hasNext() { return (next != null); } }
C'est donc dans le MessageHandler que je fais appel aux différentes méthodes de la couche du domaine (dans ce cas-ci le jeu) en fonction du message reçu.
Côté client, j'ai une classe Client qui établie les connexions avec le serveur. Et selon le port, j'instancie ou non un Dialogue.
J'ai finalement, deux principales questions:
- Comment dans mon cas créer une couche entre l'interface graphique et la communication réseau côté client ? Avec plusieurs facades en fonction des cas d'utilisation ?
- Comment se fait la gestion d'un jeu qui se jour à tour de rôle ? Notamment, je n'arrive pas à gérer les inputs reçu par message du client ?
Je sais pas si je me suis bien fait comprendre, dans le cas contraire n'hésitez pas me poser des questions :p
Merci
Partager