📋 Énoncé : Implémentation d'un Jeu de Cartes en C

Ce document décrit les exigences pour la création d'un système de gestion de cartes à jouer en C, incluant la définition des structures de données et l'implémentation des fonctions de manipulation.

Règle générale de notation :
0.5 point sera enlevé pour chaque fonction implémentée mais non testée dans la fonction main.

Partie 1 : Définition des Types (Fichier cards.h)

1.1 Contexte du Projet

On veut définir des types pour traiter des cartes à jouer. Nos cartes à jouer sont soit des cartes ayant une valeur numérique (de 1 à 10) et une couleur (pique, coeur, carreau ou treffle), soit des cartes nommées (par exemple "jocker").

1.2 Spécifications des Types

• color
  Définissez un type color (via une enum) qui peut prendre une valeur parmi : SPADES, HEARTS, DIAMONDS, et CLUBS.
• card
  Définissez un type card (via une struct) correspondant à une carte.
  • Un champ booléen doit indiquer si c'est une carte nommée.
  • Utilisez une union pour stocker :
    • Soit une structure anonyme contenant la valeur numérique (int) et la couleur (color).
    • Soit le nom de la carte (char*).
  • Les objets de ce type seront toujours manipulés par des pointeurs.
• deck et clist
  Définissez des types deck et clist correspondant à un jeu de cartes et à sa liste.
  • deck : Doit contenir deux éléments :
    1. Le nombre de cartes dans le jeu (int positif non nul).
    2. Un pointeur vers la première cellule (clist*) d'une liste doublement chaînée.
  • clist : Chaque cellule (maillon) de la liste doit contenir :
    1. Un pointeur vers la carte (card*).
    2. Un pointeur vers le deck parent.
    3. Un pointeur vers la cellule suivante (clist* next).
    4. Un pointeur vers la cellule précédente (clist* prev).
  • Les pointeurs next et prev contiendront NULL en début/fin de paquet.
  • Les objets deck et clist seront toujours manipulés par des pointeurs.

  Une note sur typedef ... deck; et clist;

  typedef struct deck_t deck;
  typedef struct clist_t clist;

  Ces lignes, placées avant la définition des structures, sont des déclarations anticipées (forward declarations).

  Elles résolvent un problème "d'œuf et de poule" :

  1. clist_t doit contenir un pointeur deck*.
  2. deck_t doit contenir un pointeur clist*.

  Lequel définissez-vous en premier ? Ces typedef disent au compilateur : "Fais-moi confiance, les types deck et clist vont exister. Tu peux les utiliser comme pointeurs pour l'instant."

  Cela permet aux deux structures de se référencer mutuellement.

1.3 Critères de notation (Types)

• 1 point pour l'énumération color.
• 2 points pour la structure card (avec l'union).
  • Note : S'il n'y a pas d'union mais que card fonctionne (tout en structure), 1 point sur 2 sera attribué.
• 2 points pour les structures clist et deck (gestion correcte de la récursion des pointeurs).

Partie 2 : Implémentation des Fonctions (Fichier cards.c)

Vous devez implémenter les fonctions suivantes (dont les prototypes sont dans cards.h) en respectant les critères de notation ci-dessous.

2.1 Fonctions de Création de Cartes (4 points)

card* createclassiccard(int value, color col);
card* createnamedcard(const char* name);

• 1 point pour le test correct des arguments (valeur, couleur, nom non-NULL).
• 1 point pour l'allocation dynamique (malloc) de la carte (avec test de réussite).
• 1 point pour l'initialisation correcte des autres champs (ex: is_named) et le return.
• 0.5 point (pour createnamedcard) pour l'allocation dynamique du nom (char*).
• 0.5 point (pour createnamedcard) pour la copie correcte de la chaîne de caractères du nom.

2.2 Création de Deck (2 points)

deck* createonecarddeck(card* c);

• 0.5 point pour l'allocation dynamique correcte du deck.
• 0.5 point pour l'allocation dynamique correcte de la première cellule (clist* start).
• 1 point pour l'initialisation correcte de tous les champs (pointeurs, nbrcards) et le return.

2.3 Ajout de Carte (4 points)

void addcardbefore(clist* l, card* newcard);

• 1 point pour l'allocation de la nouvelle cellule clist.
• 1 point pour le remplissage correct de la nouvelle cellule (carte, pointeurs next/prev).
• 1 point pour la mise à jour des pointeurs des cellules adjacentes (gestion d'au moins un cas : début ou milieu de liste).
• 1 point si les deux cas (insertion en début de liste tmp == NULL et insertion au milieu) sont gérés correctement (mise à jour de d->start si nécessaire).

2.4 Libération de Mémoire (3 points)

void freedeck(deck* d);

• 1 point si d et d->start sont correctement libérés (avec un test pour d != NULL).
• 0.5 point si le nom (char* name) des cartes nommées est également libéré le cas échéant.
• 0.5 point s'il y a une tentative de libérer la liste récursivement ou itérativement.
• 1 point (en plus du 0.5 précédent) si la libération de toutes les cellules clist et de toutes les card est faite correctement (sans fuite de mémoire).

2.5 Retrait de Carte (3 points)

card* removecard(clist* l);

• 1 point pour le test (ex: nbrcards < 2) et la mise à jour de nbrcards.
• 1 point si au moins un des cas (retrait en début de liste ou retrait au milieu/fin) est bien géré.
• 1 point si les deux cas sont gérés correctement (mise à jour de d->start, prev->next, next->prev).
• Note : 1 point sera retiré s'il y a une fuite de mémoire (ex: la cellule clist retirée n'est pas free).

2.6 Impression du Deck (3 points)

void fprintdeck (const char* filename, deck* d);

• 1 point pour l'ouverture (fopen) et la fermeture (fclose) correctes du fichier. (Les modes "w" ou "a" sont acceptés).
• 1 point pour l'exploration (parcours) correcte de la liste doublement chaînée.
• 1 point pour l'écriture correcte des données de la carte dans le fichier (gestion du cas namedcard vs carte numérique).

2.7 Distribution (Bonus)

clist** distribute(int nbplayers, deck* d);

• Cette fonction est considérée comme un bonus. Des points seront attribués "au jugé" si une tentative est faite et que la logique a du sens.

Partie 3 : Tests (Fonction main)

La fonction main doit être utilisée pour tester toutes les fonctions implémentées (sauf distribute qui est bonus).

Rappel : 0.5 point sera enlevé pour chaque fonction non testée.

Exemple de main de test fourni dans cards.c :

int main(void){
    card* c1 = createclassiccard(6,HEARTS);
    card* c2 = createclassiccard(2,SPADES);
    card* c3 = createclassiccard(3,CLUBS);
    card* c4 = createnamedcard("jocker");
    card* c5 = createnamedcard("rulescard");
    deck* d = createonecarddeck(c1);
    addcardbefore(d->start, c2);
    addcardbefore(d->start, c3);
    addcardbefore(d->start->next, c4);
    addcardbefore(d->start, c5);
    removecard(d->start);
    fprintdeck("foo1.txt",d);
    free(distribute(2,d));
    fprintdeck("foo2.txt",d);
    freedeck(d);


    return EXIT_SUCCESS;
}