Discussion :

[monsieur77]

Bonjour,
Bonjour,

je voudrais savoir comment générer un paquet de carte.
voici le début si c'est juste.
on doit pouvoir trier par exemple la dame de trèfle : Dtre

j'ai pensé à utiliser les structures

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
   struct Carte
   { char valeur[13]; // 2 3 4 5 6 7 8 9 10 V D R A
     char couleur[3]; // Piq Coe Car Tre
 
   };

mais je voudrais savoir comment associé valeur et couleur ? comme Dtre
l'exemple des coordonnées d'un point ne me semble pas si eloigner que ca.

peut etre qu'il faudrait utiliser les liste chainées.

avez vous des idées à me proposer ?

Merci

[ToTo13]

Bonjour,

si tu veux une structure pour représenter UNE carte, il vaut mieux utiliser la forme suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
typedef struct
{
char valeur ; // 2 3 4 5 6 7 8 9 10 V D R A
int couleur; // Piq 3, Coe 2, Car 1, Tre 0
} Carte ;

Cela code la valeur et la couleur d'une carte.

[Médinoc]

Je te conseille plutôt des valeurs numériques que des char:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
struct carte
{
	unsigned short valeur;
	unsigned short couleur;
};

Ensuite, les listes chaînées peuvent avoir leur utilité, mais pas forcément. La pioche par exemple, peut être simplement un tableau de 52 éléments:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
struct paquet
{
	/* Les cartes n'existeront que dans le paquet,
	toutes les autres stuctures contiendront des pointeurs
	vers ces cartes. */
	struct carte cartes[13][4];
};
 
struct pioche
{
	struct carte * tpCartes[52];
	size_t iProchaineCarte;
};

Ainsi, tu crées un paquet pour tout le jeu, que tu initialises simplement avec deux boucles for imbriquées.
Puis, tu crées une pioche, contenant un tableau de pointeurs.
Ensuite, tu mélanges la pioche, etc.

[Médinoc]

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void InitPaquet(struct paquet *pPaquet)
{
	size_t v,c;
	for(v=0 ; v<13 ; v++)
	{
		for(c=0 ; c<4 ; c++)
		{
			pPaquet->cartes[v][c].valeur = v+1;
			pPaquet->cartes[v][c].couleur = c;
		}
	}
}

[corentin59]

Pourquoi ne pas représenter une carte par un entier en base 13 ? carte = couleur * 13 + valeur, avec 0<=couleur<=3 et 0<=valeur<=12.

Si vous jetez un coup d'œil au code qui suit, vous verrez que du coup le paquet de carte en lui-même, ainsi que toutes les opérations que l'on peut imaginer dessus, se font simplement. Ainsi, la dame de trèfle est représentée par 10 et le 4 de cœur par 28 (avec les valeurs fixées dans le code). Une carte est donc définie par un entier compris entre 0 et 51.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define DEUX 0
#define TROIS 1
#define QUATRE 2
#define CINQ 3
#define SIX 4
#define SEPT 5
#define HUIT 6
#define NEUF 7
#define DIX 8
#define VALET 9
#define DAME 10
#define ROI 11
#define AS 12
 
#define TREFLE 0
#define PIQUE 1
#define COEUR 2
#define CARREAU 3
 
#define NBCARTE 52
 
int Tirage();
void Melange(int jeu[NBCARTE]);
void Affich(int carte);
 
/******************************************************************************/
/* Main                                                                       */
/******************************************************************************/
int main() {
	int i, jeu[NBCARTE];
	srand((unsigned) time(NULL));
 
	for (i=0;i<NBCARTE;i++) {
        jeu[i]=i;
        Affich(jeu[i]);
	}
 
	Melange(jeu);
 
	for (i=0;i<NBCARTE;i++) {
        Affich(jeu[i]);
	}
 
	return EXIT_SUCCESS;
}
 
/******************************************************************************/
/* Melange les cartes en faisant n permutations                               */
/******************************************************************************/
void Melange(int jeu[NBCARTE]) {
    int i, tmp, c1, c2, n=1000;
 
    for (i=1;i<n;i++) {
        c1=Tirage();
        c2=Tirage();
        tmp=jeu[c1];
        jeu[c1]=jeu[c2];
        jeu[c2]=tmp;
    }
}
 
/******************************************************************************/
/* Affiche la carte                                                           */
/******************************************************************************/
void Affich(int carte) {
    int couleur, valeur;
 
    if ( carte <= 51 ) {
        couleur = carte / 13;
        valeur = carte - couleur * 13;
 
        switch ( valeur ) {
            case DEUX: printf("2"); break;
            case TROIS: printf("3"); break;
            case QUATRE: printf("4"); break;
            case CINQ: printf("5"); break;
            case SIX: printf("6"); break;
            case SEPT: printf("7"); break;
            case HUIT: printf("8"); break;
            case NEUF: printf("9"); break;
            case DIX: printf("10"); break;
            case VALET: printf("valet"); break;
            case DAME: printf("dame"); break;
            case ROI: printf("roi"); break;
            case AS: printf("as"); break;
        }
        printf(" de ");
        switch ( couleur ) {
            case TREFLE: printf("trefle\n"); break;
            case PIQUE: printf("pique\n"); break;
            case COEUR: printf("coeur\n"); break;
            case CARREAU: printf("carreau\n"); break;
        }
    }
}
 
/******************************************************************************/
/* Genere un nombre entier aléatoire compris entre 0 et 51                    */
/******************************************************************************/
int Tirage() {
    double alea;
 
    alea = 51 * (1.0 * rand()) / RAND_MAX;
 
    return((int)alea);
}

[monsieur77]

Merci de vos réponses, etant novice dans les structure, j'ai quelque questions :

1) pk des valeurs numerique plutot que des char ?
cela veut il dire que unsigned short est un tableau de valeur uniquement positive ?
comment initialiser les valeurs que je veux 2 3 4 5 jusqu'a A
et Piq Cor etc ...
2) struct carte cartes[13][4]; pouvez vous m'expliquer celle ligne en détail ?


3) struct carte * tpCartes[52]; cette ligne va pointer sur le tableau tpcartes ?
et size_t va en choisir une aléatoirement ?

4) pPaquet->cartes[v][c].valeur = v; une petite explication

[Médinoc]

OK, je détaille un peu :

1. J'utilise des valeurs numériques car comme ça, je suis sûr qu'elles sont consécutives, et qu'elles ont un minimum et un maximum connu. Si tu veux convertir ces valeurs en chaînes, tu peux tout simplement faire un tableau de chaînes et les utiliser comme index (attention, les tableaux commencent à zéro en C).
2. Cette ligne déclare une matrice de 13*4 structures carte dans la structure paquet. Donc, elle indique que toute structure paquet contient 52 structures cartes. Et dans le jeu, on aura besoin d'une structure paquet, sans doute pas plus.
3. Cette ligne déclare un tableau de pointeurs, et chaque pointeur devra être initialisé pour pointer sur une carte. Si on mélange le tableau, les pointeurs seront mélangés (mais les cartes ne bougeront pas). Le type size_t, c'est le type conseillé pour accéder aux tableaux. Mais s'il te fait peur, on peut utiliser un bête int à la place.
4. Cette ligne accède au tableau. Elle dit "Je prends la structure carte de la case (v,c) du tableau, et je règle son champ 'valeur' avec la valeur de v". Par contre, je me suis un peu trompé, car ça ferait commencer la valeur des cartes à zéro au lieu de un. Il faut mettre ceci à la place:

   Code C :

   Sélectionner tout - Visualiser dans une fenêtre à part

   pPaquet->cartes[v][c].valeur = v+1;

   Par contre, la ligne suivante est OK et ne doit pas être modifiée : Les couleurs iront de 0 à 3 et correspondront à pique, coeur, carreau et trefle.

[monsieur77]

je te remercie pour la clarté de tes explications Médinoc.
je vais encore lire des tuto concernant les liste chainée.
L'exemple de Corentin 59 est pas mal. c'est simple et demande pas des connaissance pointu en c notamment les pointeurs ou structure. Enfin par rapport a mon niveau.

Mais a votre avis , si le programme etait en ecrit avec les structure et liste chainée, ca aurait été moin long ?

[Médinoc]

Avec des listes chaînées, je ne pense pas.
On n'a pas vraiment besoin de listes chaînées pour tirer des cartes, un tableau de structures / tableau de pointeurs de structure suffit largement.