Sixième semaine

Le Jeu de Poker !

Exercice 1	Définition de la classe `Carte`.	Carte.java
Exercice 2	Représentons maintenant les `Combinaison` s de `Carte`s ...	Paire.java Brelan.java Poker.java CinqCartes.java Quinte.java Flush.java QuinteFlush.java DeuxPaires.java Full.java
Exercice 3	Il ne nous reste maintenant plus qu'à représenter une `Main` !	Main.java Application.java

Le Poker est un jeu de cartes se jouant à plusieurs joueurs (3 à 7) avec un jeu de 52 cartes ou avec un jeu de 32 s'il n'y a pas beaucoup de joueurs. L'ordre des cartes est le suivant : as, roi, dame, valet, dix, neuf, huit, sept, six, cinq, quatre, trois, deux. Dans certaines combinaisons l'as peut compter après le deux. Les combinaisons de jeu sont les suivantes, chacune d'elles étant battue par celle qui lui est immédiatement supérieure, voici les combinaisons (en ordre croissant) :

une carte,
une paire, deux cartes de même valeur,
deux paires,
un brelan, trois cartes de même valeur,
une quinte ou séquence, cinq cartes qui se suivent et dans laquelle l'as peut compter après le deux,
un flush, cinq cartes de la même couleur,
un full ou un plein, composé d'un brelan et d'une paire,
un poker ou carré, quatre cartes de même valeur,
une quinte flush, cinq cartes de même couleur et qui se suivent et dans laquelle l'as peut compter après le deux.

La valeur d'une combinaison est celle de sa plus forte carte, à valeur égale, les quintes à coeur l'emportent sur celles d'une autre couleur. Pour les combinaisons multiples (deux paires et full) la valeur dépends des deux combinaisons.

Le donneur distribue cinq cartes à chaque joueur. Les joueurs qui ne sont pas satisfait de leur jeu peuvent écarter, un maximum de trois cartes, et recevoir de nouvelles cartes. Le joueur qui gagne est celui ayant la plus forte combinaison (il peut y avoir égalité).

Exercice 1 :

On a besoin d'une classe pour représenter une carte. On se limitera ici aux seules fontionnalitées nécessaires pour le jeu de Poker. On représente généralement une carte avec deux attributs entiers: un pour la valeur et un pour la couleur. Ce qui donne un squelette de classe Carte :

class Carte { static final int PIQUE=0, TREFLE=1, CARREAU=2, COEUR=3; static final int AS=12, ROI=11, DAME=10, VALET=9, DIX=8, NEUF=7, HUIT=6, SEPT=5, SIX=4, CINQ=3, QUATRE=2, TROIS=1, DEUX=0; protected int couleur, valeur; // couleur valeur protected boolean marque = false; // marque ... }

Les constantes définissent l'ordre des cartes : AS>ROI, ROI>DAME ... TROIS>DEUX,(DEUX>AS)

Compléter la classe Carte avec:

un constructeur avec deux paramètres entiers : valeur et couleur.
deux méthodes d'accès, en lecture, aux attributs : valeur() et couleur()
une méthode d'affichage, redéfinissant toString() , affichant une carte le mieux possible, par exemple: roi de pique

On aura besoin par la suite de trier des cartes en ordre décroissant.

Ajouter à la classe Carte une méthode estInferieureA(Carte carte), à résultat booléen, comparant la carte courante à la carte passée en paramètre, la comparaison ne se fait que sur les valeurs ; le résultat sera vrai si et seulement si la carte courante est strictement inférieure à la carte en paramètre.

Dans ce qui suit on aura besoin de marquer les cartes pour ne pas les utiliser plusieurs fois dans une combinaison. Une carte marquée a son attribut marque égal à vrai, sinon il est égal à faux.

Compléter la classe Carte avec:

une méthode marquer() forçant la marque à vrai
une méthode d'accès estMarque() retournant la marque

Indication : La marque n'apparait pas dans l'affichage des cartes.

Exercice 2 :

Il faut maintenant des classes pour représenter les combinaisons, il y a trois sortes de combinaisons :

des combinaisons avec 2 à 4 cartes de même valeur : paire, brelan et poker.
des combinaisons de 5 cartes (qui se suivent, qui ont même couleur) : quinte, flush ou quinte flush.
des combinaisons de combinaisons : deux paires ou full.

Le cas une carte n'est pas vu comme une combinaison.

Combinaisons avec 2 à 4 cartes de même valeur

Une paire est composée de deux cartes, ce qui donne un squelette de classe Paire :

class Paire { // carte + carte (de meme valeur) Carte c1, c2; ... }

Ajouter à la classe Paire :

un constructeur à deux paramètres cartes,
un constructeur à un paramètre paire,
une méthode d'affichage, exemple : Paire (7 de coeur,7 de carreau).

Un brelan est une paire plus une carte :

écrire une classe Brelan héritant de la classe Paire, la classe Brelan comportera un attribut carte, un constructeur à trois paramètres cartes, un constructeur à un paramètre brelan et une méthode d'affichage.

Un poker est un brelan plus une carte :

écrire une classe Poker héritant de la classe Brelan, la classe Poker comportera un attribut carte, un constructeur à quatre paramètres cartes et une méthode d'affichage.

Combinaisons de 5 cartes

Une classe de base est bien pratique, soit CinqCartes cette classe dont voici le squelette :

class CinqCartes { // classe de base pour Quinte et Flush Carte c1, c2, c3, c4, c5; ... }

Ajouter à la classe CinqCartes :

un constructeur à 5 paramètres cartes
une méthode cartesToString() retournant une chaîne de caractères avec toutes les cartes (ce n'est pas ici la méthode toString(), pour des problèmes liés à l'héritage il faut un autre nom), exemple : (7 de coeur, 6 de trefle, 5 de carreau, 4 de trefle, 3 de trefle).

Une quinte c'est cinq cartes qui se suivent, c'est donc CinqCartes particulières :

écrire une classe Quinte héritant de la classe CinqCartes, la classe Quinte comportera un constructeur (à cinq paramètres cartes) et une méthode d'affichage.

Un flush c'est cinq cartes de la même couleur, c'est donc CinqCartes particulières :

écrire une classe Flush héritant de la classe CinqCartes, la classe Flush comportera un constructeur (à cinq paramètres cartes) et une méthode d'affichage.

Une quinte flush est une quinte avec les cinq cartes de la même couleur, c'est donc une quinte particulière :

écrire une classe QuinteFlush héritant de la classe Quinte, la classe QuinteFlush comportera un constructeur (à cinq paramètres cartes) et une méthode d'affichage.

Combinaisons de combinaisons

Deux paires c'est une paire plus une paire :

écrire une classe DeuxPaires héritant de la classe Paire, la classe DeuxPaires comportera un attribut paire, un constructeur (à deux paramètres paires) et une méthode d'affichage.

Un full c'est un brelan plus une paire :

écrire une classe Full héritant de la classe Brelan, la classe Full comportera un attribut paire, un constructeur (à deux paramètres brelan et paire) et une méthode d'affichage.

Exercice 3 :

La main d'un joueur, c'est à dire les cartes qu'il peut jouer, est réalisée par une classe Main. La main mémorise cinq cartes, voici le squelette de cette classe :

class Main { Carte c1,c2,c3,c4,c5; ... public void trier() { // tri par la methode des bulles Carte c; if (c1.estInferieureA(c2)) { c=c1; c1=c2; c2=c; } // 1 if (c2.estInferieureA(c3)) { c=c2; c2=c3; c3=c; } if (c3.estInferieureA(c4)) { c=c3; c3=c4; c4=c; } if (c4.estInferieureA(c5)) { c=c4; c4=c5; c5=c; } if (c1.estInferieureA(c2)) { c=c1; c1=c2; c2=c; } // 2 if (c2.estInferieureA(c3)) { c=c2; c2=c3; c3=c; } if (c3.estInferieureA(c4)) { c=c3; c3=c4; c4=c; } if (c1.estInferieureA(c2)) { c=c1; c1=c2; c2=c; } // 3 if (c2.estInferieureA(c3)) { c=c2; c2=c3; c3=c; } if (c1.estInferieureA(c2)) { c=c1; c1=c2; c2=c; } // 4 } }

Pour faciliter l'écriture des méthodes sur la main, les cartes seront mémorisées dans l'ordre décroissant. La méthode trier() trie les cartes dans cet ordre.

Compléter la classe Main avec:

un constructeur avec 5 paramètres cartes,
un constructeur avec 1 paramètre vecteur de cartes,
une méthode d'affichage, redéfinissant toString() , par exemple : Main (roi de pique, dix de pique, dix de coeur, dix de trefle, six de pique).

Les constructeurs trieront les cartes, en utilisant la méthode trier().

Il s'agit maintenant d'extraire d'une main les combinaisons qui s'y trouvent. Pour cela il faut quelques méthodes ; ajouter à la classe Main :

une méthode memeCouleur(), à résultat booléen, testant si toutes les cartes de la main courante sont de la même couleur,
une méthode suiteDecroissante(), à résultat booléen, testant si toutes les cartes, de la main courante, se suivent ; ne pas oublier que l'as peut compter après le deux (si cela s'avère trop compliqué ne pas tenir compte de cette règle particulière)

Extraire les brelans et les paires c'est plus difficile, car il peut y avoir un brelan et une paire ou deux paires ; de plus dans un brelan on peut trouver deux paires. Il va donc falloir "marquer" les cartes utilisées pour un brelan ou une paire pour ne pas les réutiliser dans une autre paire.

Les deux méthodes qui suivent recherchent si la main courante contient les cartes nécessaires pour un brelan ou une paire et dans ce cas retournent une instance de la classe Brelan ou de la clase Paire contenant les bonnes cartes.

Ajouter à la classe Main :

une méthode brelan(), à résultat Brelan, testant si la main courante contient un brelan et retournant ce brelan (les trois cartes d'un brelan sont consécutives) ; s'il n'y a pas de brelan retourner null. Ne pas oublier de marquer les cartes utilisées.
une méthode paire(), à résultat Paire, testant si la main courante contient une paire et retournant cette paire (les deux cartes d'une paire sont consécutives) ; s'il n'y a pas de paire retourner null. Ne pas utiliser les cartes déja marquées et ne pas oublier de marquer les cartes utilisées.

Il ne reste plus qu'a extraire la plus forte combinaison de la main. Il faut donc les tester l'une après l'autre dans l'ordre : quinte flush, poker, full, flush, quinte, brelan, deux paires, paire ou carte.

Ajouter à la classe Main :
* une méthode extraire(), à résultat Object, recherchant dans la main courante la plus forte combinaison et retournant une instance de cette combinaison (contenant les bonnes cartes). Pour le cas une carte on retournera la plus forte carte.

NB: Le polymorphisme d'affectation est utilisé pour cette méthode.

Pour pouvoir tester vos classes, vous pourrez utiliser la classe suivante :

public class Application { static final int PIQUE=0, TREFLE=1, CARREAU=2, COEUR=3; static final int AS=12, ROI=11, DAME=10, VALET=9, DIX=8, NEUF=7, HUIT=6 SEPT=5,SIX=4, CINQ=3, QUATRE=2, TROIS=1, DEUX=0; public static void main(String args[]) { System.out.println(); Main m0=new Main(new Carte[] { new Carte(AS,PIQUE),new Carte(AS,COEUR),new Carte(AS,TREFLE), new Carte(VALET,PIQUE),new Carte(VALET,COEUR)}); System.out.println(m0); System.out.println(m0.extraire()); Main m1=new Main(new Carte[] { new Carte(AS,PIQUE),new Carte(ROI,PIQUE),new Carte(DAME,PIQUE), new Carte(VALET,PIQUE),new Carte(DIX,PIQUE)}); System.out.println(m1); System.out.println(m1.extraire()); Main m2=new Main(new Carte[] { new Carte(AS,PIQUE),new Carte(CINQ,PIQUE),new Carte(QUATRE,PIQUE), new Carte(TROIS,PIQUE),new Carte(DEUX,PIQUE)}); System.out.println(m2); System.out.println(m2.extraire()); } }

Vous devriez alors obtenir le résultat suivant :

C:\java\coo\td6\> java ApplicationMain (as de pique,as de coeur,as de trefle,valet de pique,valet de coeur) Full (Brelan (as de pique,as de coeur,as de trefle),Paire (valet de pique,valet de coeur)) Main (as de pique,roi de pique,dame de pique,valet de pique,10 de pique) Quinte flush (as de pique,roi de pique,dame de pique,valet de pique,10 de pique) Main (as de pique,5 de pique,4 de pique,3 de pique,2 de pique) Quinte flush (5 de pique,4 de pique,3 de pique,2 de pique,as de pique)