TD 5 - Jeux de cartes

Introduction

Les jeux de cartes traditionnel comprend les cartes suivantes:

Coeurs: As · 2 · 3 · 4 · 5 · 6 · 7 · 8 · 9 · 10 · Valet · Dame · Roi
Carreaux: As · 2 · 3 · 4 · 5 · 6 · 7 · 8 · 9 · 10 · Valet · Dame · Roi
Piques: As · 2 · 3 · 4 · 5 · 6 · 7 · 8 · 9 · 10 · Valet · Dame · Roi
Trèfles: As · 2 · 3 · 4 · 5 · 6 · 7 · 8 · 9 · 10 · Valet · Dame · Roi
Autres: 2 jokers
Couleurs: coeur ♥, carreau ♦, pique ♠, trèfle ♣

L'objectif que nous nous fixons est de définir des classes pour permettre de représenter des jeux de cartes. La class Carte sera définie comme suit:

enum COULEUR {COEUR, CARREAU, PIQUE, TREFLE};

public class Carte{
    // Variables de class

    static public final String[] NOMS_COULEURS = {"Coeur", "Carreau", "Pique", "Trefle"};

    static public final String[] NOMS_RANGS = {"Joker", "As", "2", "3", "4",
                     "5", "6", "7", "8", "9", "10", "Valet", "Dame", "Roi"};

    // Variables d'instance
    private final COULEUR couleur;
    private final int     rang;
    private final int     force;
    
    // Partie méthodes
}

Dans ce code, les variable de classe (attachées à la classe) se distinguent par l'usage du mot réservé static. Elles sont utilisées ici pour définir des constantes utiles dans les jeux de cartes. Les tableaux NOMS_COULEURS et NOMS_RANGS serviront à former des chaînes de caratères destinées à l'affichage de cartes. Contrairement aux variables d'instances (relative à un objet), elles sont utilisables en référant à la classe où elles sont définies.

Les énumérations de Java (type enum) permettent de définir des constantes littérales qui pourront être utilisés dans les programmes. Par exemple, le type enum COULEUR définit les littéraux COEUR, CARREAU, PIQUE, TREFLE qui serviront à coder les couleurs des cartes.

Les variable d'instance (attachées à l'objet this ) permettent de définir une carte par sa couleur, son rang et sa force. Le rang suit l'ordre du tableau NOMS_RANGS.

Le rang des cartes suit l'ordre du tableau NOMS_RANGS. La force représente la valeur relative d'une carte par rapport aux autres. Une carte l'emporte sur une autre si et seulement si elle est plus forte. Les force doivent être définies en fonction des jeux. Elles permettent de définir un ordre particulier pour un jeu (par exemple, l'As peut avoir une force supérieure au Roi dans certains jeux). Par défaut, la force est égale au rang.

Comme toutes les données qui définissent une carte sont supposées constantes au cours du jeu, les variables d'instances sont déclarées final et doivent être initialisées dans les constructeurs.

Les cartes

Nous allons compléter les méthodes dans la classe Carte

Compléter des constructeurs de la classe. Le premier constructeur prend en argument la couleur et le rang de la carte, tant dis que le deuxième prend en argument la couleur, le rang et la force de la carte.
```
    public Carte (COULEUR couleur, int rang)
    public Carte (COULEUR couleur, int rang, int force)
```

Compléter des méthodes retournant la couleur, le rang et la force de la carte.

    public COULEUR getCouleur ()
    public int getRang ()
    public int getForce ()

Compléter des méthodes retournant le nom de la couleur (selon le tableau NOMS_COULEURS) et le nom du rang de la carte (selon le tableau NOMS_RANGS). Par exemple, le nom du rang 0 est "Joker", le nom du rang 2 est "2" et celui du rang 13 est "Roi". Ensuite, compléter la méthode retournant le nom complet associé à la carte (ex, "Dame de Coeur", "10 de Trefle").
```
    public String getNomCouleur ()
    public String getNomRang ()
    public String getNomComplet ()
```

Vous pouvez tester par le fichier TestCarte.java. Le résultat affiché à l'écran doit être comme suit

9 de Coeur
Dame de Carreau
Joker
10 de Trefle

Construction des jeux de cartes

Pour jouer aux cartes, nous aurons besoin d'une classe qui gère un jeu de cartes. La classe JeuCartes sera définie comme suit:

import java.util.ArrayList;

public class JeuCartes{
    // Variable d'instance: un tableau des cartes
   private ArrayList jeu;

    // Partie méthodes
}

Pour utiliser la classe pré-définie ArrayList avec ses méthodes, nous avons importé le paquetage ArrayList de Java API. Maintenant, nous allons construire cette classe afin de joueur aux jeux de cartes.

Compléter le constructeurs de la classe qui instance un jeu de cartes vide.
```
    private JeuCartes()
```
Compléter la méthode ci-dessous qui prend une carte en argument et ajoute au jeu. La méthode retourne toujours un booléen true. Il faut utiliser la méthode add de la classe ArrayList dont la spécification est précisée ici.
```
    private boolean addCarte (Carte c)
```
Compléter la méthode ci-dessous qui ajoute toutes les cartes du rang rangDebut au rang rangFin et de couleur couleur. le rang et la force de la carte.
```
    private void addAllCartes(int rangDebut, int rangFin, COULEUR couleur)
```
Compléter la méthode ci-dessous qui retourne une représentation textuelle du jeu de cartes, c'est à dire une chaîne de caractères contenant les noms de toutes les cartes du jeu. Pour implémenter cela, la méthode getNomComplet() dans la class Carte serait utilisée.
```
    public String jeuToStringComplet()
```
Compléter la méthode ci-dessous qui prend en argument un booléen indiquant si la force de l'As doit être supérieure à toutes les autres cartes (soit une force de 14), sinon sa force est la plus petite (soit 1). La méthode retourne un jeu de 52 cartes.
```
    static public JeuCartes createJeuCartes(boolean forceAS)
```

Vous pouvez tester par le fichier TestJeuCartes.java. Le résultat affiché à l'écran doit être comme suit

Jeu de 52 cartes : [As de Pique, 2 de Pique, 3 de Pique, 4 de Pique, 5 de Pique, 6 de Pique, 
7 de Pique, 8 de Pique, 9 de Pique, 10 de Pique, Valet de Pique, Dame de Pique, Roi de Pique, 
As de Coeur, 2 de Coeur, 3 de Coeur, 4 de Coeur, 5 de Coeur, 6 de Coeur, 7 de Coeur, 
8 de Coeur, 9 de Coeur, 10 de Coeur, Valet de Coeur, Dame de Coeur, Roi de Coeur, 
As de Carreau, 2 de Carreau, 3 de Carreau, 4 de Carreau, 5 de Carreau, 6 de Carreau, 7 de Carreau, 
8 de Carreau, 9 de Carreau, 10 de Carreau, Valet de Carreau, Dame de Carreau, Roi de Carreau, 
As de Trefle, 2 de Trefle, 3 de Trefle, 4 de Trefle, 5 de Trefle, 6 de Trefle, 7 de Trefle, 
8 de Trefle, 9 de Trefle, 10 de Trefle, Valet de Trefle, Dame de Trefle, Roi de Trefle]

Pour ce qui veulent aller plus loin: Jouer les jeux de cartes

Pour jouer aux cartes, il nous faut une méthode pour la mélange des cartes. Ecrire une méthode mélangant les cartes de façons aléatoire. L'instruction suivante int n = (int) (Math.random() * MAX); fournit une valeur aléatoire entière comprise entre 0 et (MAX-1).
```
    public void melangeJeu()
```
Ensuite, il nous faut une méthode pour insérer une carte au début de talon, qui est la position 0. Compléter cette méthode.
```
    public void insererCarteTalon (Carte c)
```
Ecrire une méthode qui retourne la carte du dessus du jeu, c'est à dire la carte à la dernière position du talon. La méthode prend en argument un booléen indiquant s'il faut extraire cette carte du talon ou non.
```
    public Carte getUneCarteTalon (boolean extrait)
```
Ecrire une méthode qui prend en argument un entier indiquant le nombre de cartes demandées et un booléen indiquant s'il faut extraire les cartes du talon. La méthode retourne un tableau des cartes du talon dans l'ordre inverse (complétées par des éléments nuls si le talon n'a pas assez de carte) Le tableau a la taille égale au nombre de cartes demandées.
```
    public Carte[] getCartesTalon (int nbCartesm booleqn extrait)
```
Finalement, nous terminons par une méthode vérifiant s'il y a encore de carte dans un jeu.
```
    public boolean estVide()
```
Ecrire des méthodes pour tester vos implémentations.

Dernière mise à jour : 27/03/2013

Pour tout commentaire : thang [arobase] ibisc [point] fr