Série 10 – Jeu de Jass

Le Jass est un jeu de cartes très populaire en Suisse. Le but de cette série est d'écrire une toute petite partie des classes nécessaires à la mise en œuvre de ce jeu, principalement celle des cartes.

Pour commencer, écrivez une classe non modifiable et instanciable, nommée Card et modélisant une carte d'un jeu de 36 cartes.

Les deux attributs d'une telle carte sont sa couleur (piques, carreaux, trèfles ou cœurs) et sa valeur (six, sept, huit, neuf, dix, valet, dame, roi ou as). Chacun de ces attributs se représente idéalement au moyen d'une énumération Java, la première nommée p.ex. Suit, la seconde Rank (noms anglais de ces attributs). Un accesseur doit être fourni pour chacun d'entre-eux.

Votre classe des cartes doit implémenter l'interface Comparable de telle manière que les cartes soient triées d'abord par couleur puis par valeur, dans l'ordre donné plus haut (piques d'abord, carreaux ensuite, etc. puis dans une même couleur le six d'abord, le sept ensuite, etc.).

Etant donné que les cartes sont non modifiables (« immutables »), votre classe doit redéfinir également les méthodes equals et hashCode.

Afin que les cartes puissent être affichées à l'écran sous une forme compréhensible, votre classe doit offrir une méthode frenchName retournant le nom français d'une carte. Pour la mettre en œuvre, ajoutez aux deux énumérations mentionnées ci-dessus une méthode frenchName. Cela vous permettra de voir comment ajouter du code à une énumération Java.

Une fois la classe des cartes terminée, votre but est d'écrire une classe nommée p.ex. JassGame et modélisant un jeu de Jass. Une version réaliste de cette classe posséderait probablement des attributs comme les joueurs, un tas de cartes, des plis, etc. Pour cet exercice, vous vous contenterez d'en écrire un embryon très simple dont tout le code sera placé dans des méthodes statiques. Cela n'est pas très propre mais simplifie les choses. Nous vous proposons d'offrir les méthodes suivantes :

• List<Card> buildDeck(), qui retourne un liste contenant les 36 cartes d'un jeu standard,
• void shuffleDeck(List<Card> deck), qui mélange les cartes d'une liste (aidez-vous de la méthode shuffle de la classe Collections),
• List<List<Card>> dealDeck(List<Card> deck, int stacksCount), qui distribue les cartes du tas deck (qu'on suppose mélangé au besoin) en stacksCount parties de taille égale ou lève l'exception IllegalArgumentException si le tas ne peut être distribué en ce nombre de parties,
• int cardPoints(Card c, Card.Suit trump), qui retourne la valeur d'une carte en points selon les règles du Jass, étant donné l'atout trump.

Pour terminer, écrivez un petit programme principal qui crée un tas de 36 cartes, le mélange, et le distribue entre 4 joueurs puis affiche les mains de chacun avec leur valeur, en faisant l'hypothèse que l'atout est piques. La sortie de votre programme devrait ressembler à ceci :

Main du joueur n°1 (vaut un total de 43 points).
  neuf de piques
  dix de piques
  huit de carreaux
  roi de carreaux
  as de carreaux
  six de trèfles
  huit de trèfles
  roi de trèfles
  six de cœurs
Main du joueur n°2 (vaut un total de 38 points).
  six de piques
  sept de piques
  valet de piques
  six de carreaux
  valet de carreaux
  dame de carreaux
  sept de trèfles
  valet de trèfles
  as de trèfles
Main du joueur n°3 (vaut un total de 38 points).
  roi de piques
  as de piques
  sept de carreaux
  dix de carreaux
  neuf de trèfles
  dame de trèfles
  sept de cœurs
  huit de cœurs
  dix de cœurs
Main du joueur n°4 (vaut un total de 33 points).
  huit de piques
  dame de piques
  neuf de carreaux
  dix de trèfles
  neuf de cœurs
  valet de cœurs
  dame de cœurs
  roi de cœurs
  as de cœurs

Notez que la somme totale des points vaut 152 comme il se doit, et que les cartes de chaque main sont ordonnées comme mentionné précédemment.

Afin d'afficher les cartes d'une main dans l'ordre, nous vous proposons d'écrire une méthode qui, étant donné un itérateur quelconque, produit un autre itérateur qui retourne les mêmes éléments que le premier mais ordonnés selon leur ordre naturel. Il s'agit d'un excellent exercice pour entraîner les concepts vus jusqu'à présent ! Aidez-vous au besoin des méthodes sort et unmodifiableList de la classe Collections.