Discussion :

[Gaspoute]

Bonjour,

Je suis actuellement en train de créer un petit client/serveur et pour cela j'utilise le pattern Commande. Du côté du serveur, à chaque message reçu par le client une commande est créée et exécutée. J'ai cependant un doute sur la façon dont elle est créée.

Donc, dans chacune de mes commandes, je fais appel à des méthodes appartenant à la couche "domaine". Un exemple:

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
public class GameAttachObserverCommand implements ICommand {
	private ClientID clientID;
	private IObserver observer;
	
	public GameAttachObserverCommand(ClientID clientID, IObserver observer) {
		this.clientID = clientID;
		this.observer = observer;
	}
	
	public void execute() {
		IGame game = GameCenter.getInstance().getGame();
		game.attachObserver(observer);
	}
}

Elle est crée par une fabrique.

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
public class CommandFactory implements ICommandFactory {
	private static CommandFactory instance;
	
	private CommandFactory() {}
	
	public static CommandFactory getInstance() {
		if (instance == null) {
			instance = new CommandFactory();
		}
		return instance;
	}
	
	public ICommand getCommand(Connection connection, Message message) {
		HostedConnection hostedConnection = (HostedConnection) connection;
		ClientID clientID = hostedConnection.getClientID();
		
		switch (message.getType()) {
			case GAME_ATTACH_OBSERVER:
				ObserverID observerID = (ObserverID) message.getData("observerID");
				return new GameAttachObserverCommand(clientID, new ObserverProxy(clientID, observerID));
				
			default:
				return null;
		}
	}
}

Et qui est elle-même appelée dans un MessageHandler qui s'occupe de récupérer la commande créée par la fabrique à partir du message que le handler lui passe et de l'exécuter.

La question que je me pose est la suivante: est-ce que la manière dont j'instancie ma commande dans la fabrique est correcte ? Donc est-ce que je fais bien de construire ma commande avec l'ID du client et un Observer plutôt que de lui passer le message et la connexion ? Dans ce dernier cas, ce serait à elle de récupérer ce dont elle a besoin dans le message.

La première solution me semble la meilleure vu qu'on découple un peu plus la création d'une commande et la récupération des données contenues dans le message, mais je voudrais tout de même avoir votre avis.

Merci

[Luckyluke34]

La commande s'appelle GameAttachObserverCommand donc ça me parait en effet beaucoup plus cohérent qu'elle traite avec un ID client et un Observer plutôt que de lui passer le message et la connexion.

A voir si on ne peut pas sortir la logique de transformation d'un Message en Commande :

Code :

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

1
2
ObserverID observerID = (ObserverID) message.getData("observerID");
return new GameAttachObserverCommand(clientID, new ObserverProxy(clientID, observerID));

dans une sorte de Converter spécialisé. J'imagine qu'il va y avoir toutes sortes de commandes dans ton système donc à terme la Factory va être obèse et un peu omnisciente, ce qui n'est pas très maintenable.

Autre remarque : on a l'impression que tu as essayé de caser énormément de patterns (Command, Observer, AbstractFactory, Proxy...) dans ton code. Ne connaissant pas le domaine, je ne remets pas en cause leur utilisation mais le fait est que des classes comme ObserverProxy posent un peu question Sont-ils tous réellement indispensables ?

[Gaspoute]

Pour tout vous dire, j'essaie de créer un petit jeu (TicTacToe) en réseau avec d'autres options à côté. J'essaie dans la mesure du possible de séparer la couche du domaine du reste donc de faire en sorte que mon jeu puisse fonctionner en local et en réseau. La couche réseau (côté serveur) surplombe la couche du domaine.

Cela fait un petit temps que je teste plusieurs choses suite à des avis faits sur différents forums. Et j'ai notamment lu que la pattern commande pouvait être utile pour les jeux, mais que le proxy l'était tout autant.

J'ai essayé les deux. Dans le premier cas, j'ai créé plusieurs facades côté client qui envoient des messages transformés en commandes côté serveur. Et dans le second cas, j'utilise un proxy côté client qui communique au moyen de messages avec l'objet réel côté serveur.

Je ne sais pas laquelle des deux façons est la meilleure ni s'il en existe d'autres.

De plus, je n'arrive pas à bien visualiser comment je pourrai gérer les inputs des joueurs en tenant compte que suivant le jeu (car d'autres viendront s'ajouter) les données nécessaires pour réaliser un mouvement changent et donc comment rendre tout cela le plus homogène possible avec des interfaces.

Pour répondre à votre message, je n'ai pas trouver d'autre alternative pour utiliser le pattern observer à travers le réseau que de créer un ObserverProxy côté serveur qui joue le rôle du réel Observer côté client. Mais peut-être avez -vous une autre idée ? :p

En tout cas, merci de votre aide

[Luckyluke34]

De plus, je n'arrive pas à bien visualiser comment je pourrai gérer les inputs des joueurs en tenant compte que suivant le jeu (car d'autres viendront s'ajouter) les données nécessaires pour réaliser un mouvement changent et donc comment rendre tout cela le plus homogène possible avec des interfaces.

Je ne connais pas la nature des autres jeux, mais ces interfaces doivent logiquement représenter le plus petit dénominateur commun entre les commandes possibles dans ces différents jeux.

Il faut aussi bien voir que l'orienté objet, ce n'est pas utiliser une interface ou une classe abstraite pour le plaisir de représenter de manière homogène des choses plus ou moins liées dans le monde réel. Cette homogénéité doit vraiment servir notre système. Si dans le moteur générique de jeu on n'a aucun intérêt à ce que, par endroits, tous les mouvements de tous les jeux soient visibles comme la même chose, alors cette interface est inutile.

Pour répondre à votre message, je n'ai pas trouver d'autre alternative pour utiliser le pattern observer à travers le réseau que de créer un ObserverProxy côté serveur qui joue le rôle du réel Observer côté client. Mais peut-être avez -vous une autre idée ? :p

OK, je comprends mieux. Non, c'est juste que de loin ça faisait un peu "pattern abuse"

Un lien intéressant sur l'implémentation "à la main" d'Observers distants : http://www.cs.sjsu.edu/faculty/pearc...1/rmi/rmi.html

[Gaspoute]

J'essaie justement de ne pas utiliser RMI :p

Les jeux seront principalement des petits jeux qui se jouent à tour de rôle. L'année passée, j'ai du réaliser un travaille de groupe qui consistait à créer une petite plateforme de ce type de jeux. Nous devions notamment implémenter le tic tac toe et les dames. J'étais pas très fier du travaille réalisé, je trouvais ça un peu bâclé alors j'ai décidé de repartir de zéro.

Est-ce que selon vous le pattern commande est-il vraiment utile pour un jeu ?

Au début, je pensais avoir principalement 3 classes: Game, Board et Player. Le Board étant passé au contructeur du Player pour qu'à l'appel de takeTurn(), il effectue un mouvement sur le tableau. Game boucle sur les joueurs jusqu'à ce qu'il y ait un gagnant ou que le jeu soit bloqué. Il y aurait donc plusieurs types de joueur. C'est ma vision générale. Je sais pas si c'est la bonne lorsqu'il s'agit d'un jeu en réseau. D'ailleurs, je me demande comment je donne la main à un joueur, comment je bloque les autres et comment je récupère le mouvement joué.

Vous avez peut-être des idées à me proposer ? Enfin je l'espère ^^

Merci

[Luckyluke34]

Les opérations qu'on peut effectuer dans un système sont généralement contenues dans des méthodes. Le pattern Command va un cran plus loin, il permet de penser non plus à ce que fait l'opération mais à l'opération elle-même en tant qu'objet abstrait. Le but est de faire plein de choses avec celle-ci sans forcément l'exécuter :

• La stocker pour plus tard
• L'annuler, la rejouer
• Traiter toutes les opérations d'un certain type de la même manière en faisant des choses après ou avant qu'elles soient exécutées
• Etc

Dans le cas d'un jeu vidéo, on peut imaginer plein de raisons pour lesquelles on voudrait avoir des Commandes plutôt que de se contenter d'appeler des méthodes bêtement : pour retarder l'action d'un joueur bloquée temporairement, orchestrer les actions de plusieurs joueurs, détecter des "combos" en analysant une séquence d'actions, enregistrer les actions pour permettre un "replay", etc.

Dans les jeux au tour par tour, le concept de Commande se marie très bien avec celui de règle du jeu puisque chaque Commande peut représenter une action légitime d'un joueur à son tour de jeu. Ceci dit, ce n'est pas forcément nécessaire pour des jeux simples comme Tic Tac Toe et une version sans commandes peut suffire.

Sur la meilleure manière de concevoir le modèle objet d'un jeu en général, je n'en sais rien du tout... Peut être poser la question sur le forum "Développement 2D, 3D et Jeux" ?

[Gaspoute]

Compris, merci

Je m'en vais de suite leur exposer mon problème.