TD n° 11 : Simulation du jeu de cartes de la bataille

TD de programmation structurée : 1ère année
2016-2017
TD n° 11 : Simulation du jeu de cartes de la bataille
Buts
Durée
: Types abstrait
: 1 séance
On distribue les 52 cartes une par une aux 2 joueurs qui les rassemblent en paquet, face cachée,
devant eux. On appellera ces deux paquets les jeux des joueurs.
Chacun tire la carte du dessus de son jeu et la pose sur la table, face découverte, à coté de son jeu.
Celui qui a la carte la plus forte ramasse les autres cartes.
Le roi est la plus forte carte, puis vient la dame, le valet, le 10, 9,...3,2,As (On peut aussi jouer avec
l’ordre As, Roi, Dame,...3,2.)
Lorsque deux joueurs posent deux cartes de même valeur, il y a "bataille". Lorsqu'il y a bataille, les
joueurs tirent la carte suivante et la posent, face cachée, sur la carte précédente, à coté du jeu. Puis
ils tirent une deuxième carte qu'ils posent cette fois-ci face découverte. C’est cette dernière carte
découverte qui départagera les joueurs. Si ces cartes sont aussi identiques, il y a à nouveau bataille
et on tire à nouveau une carte que l’on pose face cachée sur les précédentes, puis on tire une
nouvelle carte que l’on pose face découverte sur les précédentes : la plus forte remporte toutes les
cartes posées, et s’il y a à nouveau bataille, on recommence...
Le gagnant est celui qui remporte toutes les cartes.
Lorsqu’un des deux joueurs n’a pas assez de cartes pour continuer une bataille en cours (c’est la
notion de famine), ce joueur a perdu.
Pour simuler le jeu, les structures de données utilisées sont des files et des piles.
Le jeu de chaque joueur peut être représenté par une file. Au début du tour, le joueur prend la carte
du dessus et s’il gagne, il prend les cartes jouées et les ajouter par dessous (enfiler).
Les paquets de bataille sont des piles, car on ajoute toujours sur le sommet du paquet et on regarde
et compare la carte du sommet.
Le jeu se termine quand les suites sont complètes (on a gagné ou lorsque le jeu est bloqué (on a
perdu).
Travail à réaliser :
1. Faire un programme qui simule le jeu de la bataille en utilisant les fonctions réalisées
précédemment et la fonction de distribution donnée. Attention, cette dernière utilise une
fonction File enfiler(CARTE, File) que vous devez avoir écrite.
2. Ajouter la gestion de la famine, lorqu’un joueur n’a plus aucune carte et perd la partie
3. Gérer un affichage graphique des différents éléments du jeu (talon, colonnes, suites)
Version graphique
Des fonctions permettant d’afficher des files et des piles de cartes sous forme graphique sont
disponibles. Pour les files, ces fonctions utilisent une représentation des files par liste circulaire.
La structure de données représentant une carte contient alors son rang, sa couleur, si elle est face
cachée ou non et une nouvelle structure "im" de type ICONE qui contient une image 32 bits ainsi
que la dimension de cette image.
typedef struct {
unsigned int** data; int lig, col; } ICONE;
typedef struct {
int rang; char visible; char couleur; ICONE im;} CARTE;
Voici les fonctions utiles ;
• Création des cartes, mélange de ces cartes avec leurs images et distribution des cartes dans
les files *ajeu1 et *ajeu2, avec nbcarte pour chaque couleur (nbcarte<14) et en
utilisant alea pour démarrer le tirage aléatoire. Pour debugger, utiliser une valeur non nulle
pour alea. Pour obtenir des tirages différents, utiliser ensuite des valeurs différentes à
chaque exécution.
int distribution(File* ajeu1, File* ajeu2, int alea, int
nbcarte)
Attention : cette fonction utilise la fonction File enfiler(ELEMENT e, File f)
que vous devez avoir écrite et tester lors du tp précédent.
• affiche une carte à une position :
void affichegr(CARTE* e, SDL_Surface* f1,int x, int y)
• efface une carte à une position :
void effacegr(CARTE* e, SDL_Surface* f1,int x, int y)
• Affiche une pile de carte à une position donnée, en décalant les cartes de "decalage"
pixels à chaque fois. decalage peut être positif ou négatif. On tient compte des faces
cachées.
void graphe_pile_d(Pile p, SDL_Surface* f1, int x, int y,
int decalage)
• Efface une pile de carte à une position donnée, en décalant les cartes de "decalage"
pixels à chaque fois.
void effacegr_pile_d(Pile p, SDL_Surface* f1, int x, int
y, int decalage)
• Affiche une file de carte à une position donnée, en décalant les cartes de "decalage"
pixels à chaque fois. decalage peut être positif ou négatif. On tient compte des faces
cachées.
void graphe_file_d(File L, SDL_Surface* f1, int x, int y,
int decalage)
• Efface une file de carte à une position donnée, en décalant les cartes de "decalage" pixels
à chaque fois.
void effacegr_file_d(File L, SDL_Surface* f1, int x, int
y, int decalage)
Voici un exemple qui crée une file de cartes mélangées et faces cachées et une pile de cartes faces
visibles (fichier exemple.c)
#include <SDL/SDL.h>
#include <SDL_phelma.h>
#define DECALAGE (20)
#include "file.h"
#include "pile.h"
#include "carte.h"
#define DIMX 400
#define DIMY 550
int main(int argc, char** argv) {
int i;
2/3
// le talon est une file de cartes
File talon=creer_file();
// p est une pile de cartes
Pile p=creer_pile();
// Une carte
CARTE c;
// La fenetre graphique
SDL_Surface* f1=NULL;
/* On crée et mélange toutes les cartes (ici 5*4),
avec leur representation sous forme d'image
dans la file jeu*/
i=melanger(&talon,1,5);
if (i==0) { puts("Il manque les fichiers graphiques"); exit(1); }
/* On cree une fenetre graphique */
f1=newfenetregraphique(DIMX,DIMY);
/* On affiche le talon complet en x=50,
y=10 : Les cartes sont affichees avec un
decalage verticale de -20 pixels
*/
graphe_file_d(talon,f1,50,10,-20);
/* On cree une pile avec les premieres
cartes du talon
*/
for (i=0; i<10; i++) {
c=defiler(&talon);
c.visible=1 ;
p=empiler(c,p);
}
/* On affiche la pile en x=200, y=100;
Les cartes sont affichees avec un decalage
vertical de -20 pixels
*/
graphe_pile_d(p,f1,200,100,-20);
/* On affiche une carte isolee visible prise sur le talon en 50,300 */
c=defiler(&talon);
c.visible=1 ;
affichegr(&c,f1,50,300);
}
3/3