Discussion :

[le Daoud]

Bonjour,

je ne sais pas comment résoudre la question suivante :
J'ai une interface IArbitre qui gère les règles d'un jeu. J'aimerais avoir une méthode qui vérifie si un coup est valide, et je pense qu'elle a toute sa place dans cette interface, en effet c'est une méthode que je vais retrouver pour tous les jeux. Mais cette méthode doit donc recevoir un coup en paramètre. Or je peux avoir plusieurs types de coups. J'ai donc pensé créer une interface ICoup, mais je n'ai rien à mettre dedans... Est-ce choquant ? (ça me parait absurde)
Une idée ?

merci
daoud

[nic58]

Moi ça me choque pas, car si un jour tes coups doivent tous avoir une même méthode, et bien tu n'auras cas la mettre dans ton interface.
Ca sera prêt.
Mais bon, je suis plutôt novice en modélisation et tout ce qui va avec alors ...

[Franckintosh]

Je suis d'accord avec nic58, mais en attendant que tu remplisses ton interface tu ne peux rien faire avec tes ICoup ;-).
Si ce sont des types de coup il doit bien y avoir des actions communes (dans le concept, pas forcément l'implémentation) pour vérifier ou aider à vérifier la validité d'un coup.

[le Daoud]

Salut,

merci pour vos réponses
En fait, c'est mon IArbitre qui vérifie si le coup est valide, par exemple:

Code :

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

1
2
public boolean isValid(ICoup c, IPlateau p)

Mes coups ne sont que des objets avec des coordonnées :
ex

Code :

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

1
2
3
4
5
6
7
public class CoupDebut {
  private int ligne;
  private int index;

 // constructeur et getters
}

et

Code :

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

1
2
3
4
5
6
7
8
9
public class CoupMilieu{
  private int ligneDepart
  private int ligneArrivee;
  private int indexDepart;
  private int indexArrivee;

  //constructeur et getters
}

Donc ce que je fais dans ma méthode isValid par exemple c'est

Code :

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

1
2
3
4
5
if(coup instanceof CoupDebut)
  ...
else
 ...

voilà, je ne vois donc rien à mettre dans mon ICoup...

daoud

[nic58]

Bah, si tu veux vraiment une fonction, fais en une qui permet de réinitialiser ton objet "coup".

Sinon, tu n'as pas besoin de la direction d'un coup (je demande car je ne sais pas ce qu'est réellement ton objet "coup") ?
Car si c'est le cas chaque objet coup peut calculer la sienne et donc ça te fait une fonction commune à tous tes objets.

[le Daoud]

Merci,

Je n'ai pas d'envie particulière de remplir cette interface . Je me demandais si cela n'était pas lié à un défaut de conception...et s'il y avait un moyen plus intelligent de faire cela.

a+
daoud

[Franckintosh]

voilà, je ne vois donc rien à mettre dans mon ICoup...

Ben moi si, les accesseurs des attributs dont tu as besoin pour valider un coup. Si tu ne les mets pas dans l'interface tu ne peux pas y accéder.
Mais comme apparement il n'y en a pas en commun je suggère de faire une fonction par type de coup qui sera appelée par celle qui demande un ICoup en entrée.

[le Daoud]

Merci

Je ne suis pas certain d'avoir compris ce que tu me proposes. Mettre des fonctions dans l'interface ?
Mon problème est que j'aimerais faire quelque chose qui soit le plus générique possible afin de le réutiliser dans d'autres jeux. Or un coup dans un jeu peut-être complétement différent dans un autre, en plus d'être parfois, comme dans mon cas, différent dans le même jeu.
C'est pourquoi j'avais temporairement adopté cette solution et tester le type avec un instanceof...

j'ai mal à la tête
daoud

[Franckintosh]

Pour une utilisation propre de l'interface il faudrait appeler les méthodes de l'interface dans l'implémentation. Or comme les coups réels sont différents tu ne peux pas modéliser de méthodes communes dans l'interface.
Un petit exemple d'implémentation pour montrer ma proposition que tu n'as pas compris :

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
public boolean isValid(ICoup coup, IPlateau p)
{
...
if(coup instanceof CoupDebut)
  return isValid( (CoupDebut) coup, IPlateau p)
elseif(coup instanceof Coup1)
  return isValid( (Coup1) coup, IPlateau p)
elseif(coup instanceof Coup2)
  return isValid( (Coup2) coup, IPlateau p)
else
 ...
}

private boolean isValid(CoupDebut coup, IPlateau p){traitement pour un CoupDebut}
private boolean isValid(Coup1 coup, IPlateau p){traitement pour un Coup1}
private boolean isValid(Coup2 coup, IPlateau p){traitement pour un Coup2}

Ce n'est pas révolutionnaire mais ça permet d'avoir un minimum de contrôle de type. De plus les IsValid spécifiques pourraitent se trouver ailleurs dans un ensemble regroupant tout ce qui est spécifique à un certain type de coup par exemple, ce qui pourrait rendre beaucoup plus modulaire et donc interchangeable ta gestion de l'arbitrage.

[le Daoud]

Merci