UNO en langage C

Version imprimable

Voir 40 message(s) de cette discussion en une page

02/06/2007, 19h33
enzo_fxx

Désolé mais l'indentation a changé quand j'ai posté le message.

J' ai trouvé un code source qui mélange des cartes, peut tu me dire si je peut utiliser la meme démarche pour définir mon jeu de carte.

Code:

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
#include <stdio.h>
#include <stdlib.h>  /* Contient les fonctions srand er rand */
#include <time.h>    /* Contient la fonction time */
 
 
typedef struct carte{
  char *valeur;
  char *couleur;
}Carte;
 
 
/* Initialise le jeu pour qu'il contienne les
 * 52 cartes d'un jeu standard
 */
void init(Carte *jeu){
  char *valeur[]={"As", "Deux", "Trois", "Quatre", "Cinq", "Six",
		    "Sept", "Huit", "Neuf", "Dix", "Valet", "Dame", "Roi"};
  char *couleur[]={"Coeur", "Carreau", "Trefle", "Pique"};
  int i;
 
  for(i=0; i<52; i++){
    jeu[i].valeur=valeur[i%13];
    jeu[i].couleur=couleur[i/13];
  }
}
 
 
/* Affiche les 52 cartes dans l'ordre ou
 * elle apparaissent dans le tableau jeu
 */
void afficher(Carte *jeu){
  int i;
  for(i=0; i<26; i++){
    printf("%6s de %-7s",jeu[2*i].valeur, jeu[2*i].couleur);
    printf("\t%6s de %-7s\n", jeu[2*i+1].valeur, jeu[2*i+1].couleur);
  }
}
 
 
void melanger(Carte *jeu){
  int i,n;
  Carte tmp;
  srand(time(NULL)); /* Initialise le generateur pseudo aleatoire */
  for (i=0; i<52; i++){
    n=rand()%52;     /* n est un nombre pseudo aleatoire entre 0 et 51 */
    tmp=jeu[i];
    jeu[i]=jeu[n];
    jeu[n]=tmp;
  }
}
 
 
main(){
  Carte jeu[52];
  init(jeu);
  melanger(jeu);
  afficher(jeu);
  system("pause");
}

03/06/2007, 16h04
Emmanuel Delahaye

Citation:

Envoyé par enzo_fxx

J' ai trouvé un code source qui mélange des cartes, peut tu me dire si je peut utiliser la meme démarche pour définir mon jeu de carte.

Oui, sauf que srand() doit être placé dans la première instruction du main().
03/06/2007, 16h06
Emmanuel Delahaye

Citation:

Envoyé par enzo_fxx

Désolé mais l'indentation a changé quand j'ai posté le message.

J'ai mis les balises code, mais ça reste illisible. Ce genre de tableau doit être fait dans un éditeur réglé en mode space (et non 'tabs'), puis copié/collé entre 2 balises de code.

Peut tu m'expliquer l 'initialisation dans le CS ?

Code:

1
2
3
4
5
6
7
8
9
10
void init(Carte *jeu){
  char *valeur[]={"As", "Deux", "Trois", "Quatre", "Cinq", "Six",
		    "Sept", "Huit", "Neuf", "Dix", "Valet", "Dame", "Roi"};
  char *couleur[]={"Coeur", "Carreau", "Trefle", "Pique"};
  int i;
 
  for(i=0; i<52; i++){
    jeu[i].valeur=valeur[i%13];
    jeu[i].couleur=couleur[i/13];
  }

Citation:

Envoyé par enzo_fxx

Peut tu m'expliquer l 'initialisation dans le CS ?

Code:

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
void init(Carte *jeu)
{
/* definition de deux tableaux de pointeurs sur des chaines de caracteres 
 
Nota : les chaines de caractères sont définies dans une zone mémoire
         persistante, leur adresse est donc toujours valide.
*/
  char *valeur[]={"As", "Deux", "Trois", "Quatre", "Cinq", "Six",
		    "Sept", "Huit", "Neuf", "Dix", "Valet", "Dame", "Roi"};
  char *couleur[]={"Coeur", "Carreau", "Trefle", "Pique"};
  int i;
 
  /* Rappel : 52 cartes = 4 couleurs de 13 figures (ou valeurs) */
  for(i=0; i<52; i++)
  {
    /* l'indice i varie de 0 a 51 */
 
    /* L'indice de valeur[] varie de 0 a 12 (0 à 51 %13). 
 
        0-12 : 0-12
        13-25 : 0-12
        etc.
 
        Il parcourt donc le tableau de valeur. 
        L'adresse des chaines est stocké dans la structure
   */
    jeu[i].valeur=valeur[i%13];
 
    /* l'indice de couleur[] varie de 0 a 3 (0 à 51 /13 : division entiere). 
 
        0-12 : 0
        13-25 : 1
        etc.
 
        Il parcourt donc le tableau de couleur. 
        L'adresse des chaines est stocké dans la structure
   */ 
    jeu[i].couleur=couleur[i/13];
  }

C'était difficile ?

En suivant la démarche du CS j'ai fait ceci:

Code:

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
 
typedef struct
{
   char *couleur;
   char *valeur;
   char *jockers;
   char *zero;
}
carte;
void init (carte * jeu)
{
   char *couleur[] = { "BLEU", "ROUGE", "VERT", "JEUNE" };
   char *valeur[] =
      { "UN", "DEUX", "TROIS", "QUATRE", "CINQ", "SIX", "SEPT", "HUIT",
"NEUF" };
   char *jockers[] = { "PLUSDEUX", "INVERSION", "PASSER_TOUR" };
   char *zero[] = { "ZERO" };
   int i;
   for (i = 0; i < 72; i++)     /*72 cartes basiques de 1 à 9 associés au couleurs */
   {
      jeu[i].valeur = valeur[i % 9];
      jeu[i].couleur = couleur[i / 9];
   }
   for (i = 0; i < 24; i++)     /*24 cartes jockers associés au couleurs */
   {
      jeu[i].jockers = jockers[i % 3];
      jeu[i].couleur = couleur[i / 3];
   }
   for (i = 0; i < 4; i++)      /*4 cartes zero de chaque couleur */
   {
      jeu[i].zero = zero[i % 1];
      jeu[i].couleur = couleur[i / 1];
   }
}

[-mod- Code remis en forme suite à fausse manip de ma part...]

Citation:

Envoyé par enzo_fxx

En suivant la démarche du CS j'ai fait ceci:

Code:

1
2
3
4
5
6
7
typedef struct
{ 
      char  *couleur;
      char  *valeur;
      char  *jockers;
<...>    
}

C'est compliqué d'écrire joker à la place de jocker ?

D'autre part, tu écrases joyeusement ce que tu as fait à la boucle précédente. Il ne faut pas réinitialiser i, et il faut le faire aller où il faut... (72, 72+24, 72+24+4), bref, il faut réfléchir avant de coder...

Après reflexion, j'obtiens ceci :

Code:

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
112
113
114
115
116
117
118
119
120
121
 
#include <stdio.h>
#include <string.h>
 
typedef struct
{
   char const *valeur;
   char const *joker;
   char const *zero;
   char const *couleur;
}
carte_s;
 
typedef struct
{
   carte_s cartes[72 + 24 + 4];
}
uno_s;
 
void init (uno_s * p_jeu)
{
   char const *valeur[] =
      { "UN", "DEUX", "TROIS", "QUATRE", "CINQ", "SIX", "SEPT", "HUIT",
      "NEUF"
   };
   char const *joker[] = { "PLUSDEUX", "INVERSION", "PASSER_TOUR" };
   char const *zero[] = { "ZERO" };
   char const *couleur[] = { "BLEU", "ROUGE", "VERT", "JAUNE" };
 
   int i;
   int j;
 
/* 72 cartes basiques de 1 à 9 associés au couleurs */
   for (i = 0; i < 72; i++)
   {
      p_jeu->cartes[i].valeur = valeur[i % 9];
      p_jeu->cartes[i].joker = NULL;
      p_jeu->cartes[i].zero = NULL;
      p_jeu->cartes[i].couleur = couleur[i / (72 / 4)];
   }
 
/* 24 cartes jokers associés au couleurs */
   for (j = 0; i < 72 + 24; i++)
   {
      p_jeu->cartes[i].valeur = NULL;
      p_jeu->cartes[i].joker = joker[j % 3];
      p_jeu->cartes[i].zero = NULL;
      p_jeu->cartes[i].couleur = couleur[j / (24 / 4)];
      j++;
   }
 
/* 4 cartes zero de chaque couleur */
   for (j = 0; i < 72 + 24 + 4; i++)
   {
      p_jeu->cartes[i].valeur = NULL;
      p_jeu->cartes[i].joker = NULL;
      p_jeu->cartes[i].zero = zero[j % 1];
      p_jeu->cartes[i].couleur = couleur[j / (4 / 4)];
      j++;
   }
}
 
static int put_dot (char *s, int first)
{
   if (!first)
   {
      strcat (s, ".");
   }
   else
   {
      first = 0;
   }
   return first;
}
 
static void display (uno_s * p_jeu)
{
   int i;
 
   for (i = 0; i < 72 + 24 + 4; i++)
   {
      int first = 1;
      char s[128] = "";
 
      if (p_jeu->cartes[i].valeur != NULL)
      {
         first = put_dot (s, first);
         strcat (s, p_jeu->cartes[i].valeur);
      }
 
      if (p_jeu->cartes[i].joker != NULL)
      {
         first = put_dot (s, first);
         strcat (s, p_jeu->cartes[i].joker);
      }
 
      if (p_jeu->cartes[i].zero != NULL)
      {
         first = put_dot (s, first);
         strcat (s, p_jeu->cartes[i].zero);
      }
 
      if (p_jeu->cartes[i].couleur != NULL)
      {
         first = put_dot (s, first);
         strcat (s, p_jeu->cartes[i].couleur);
      }
 
      puts (s);
   }
}
 
int main (void)
{
   uno_s jeu;
   init (&jeu);
#if 1
   display (&jeu);
#endif
   return 0;
}

Evidemment, c'est un peu plus compliqué que ce que tu pensais. C'est parce que la version (52 cartes) est extrêmement simple (un seule carte par couleur). Ici, c'est plus complexe, et il faut parfois faire plusieurs tours, d'où une formule de calcul un peu plus complexe (mais régulière).

06/06/2007, 23h27
enzo_fxx

Salut tu pourrai m'expliquer comment tu a procédé, désolé de pas avoir répondu plus tot j'étais occupé sur un autre projet.
En tout cas merci beaucoup pour ton aide.
07/06/2007, 01h13
Emmanuel Delahaye

Citation:

Envoyé par enzo_fxx

Salut tu pourrai m'expliquer comment tu a procédé, désolé de pas avoir répondu plus tot j'étais occupé sur un autre projet.
En tout cas merci beaucoup pour ton aide.

Bah, faut lire le code. Après c'est du calcul entier. C'est pas clair ?
07/06/2007, 09h00
enzo_fxx
Pour la fonction init j'ai compis c'est la fonction put_dot et display que j'ai pas compris.
Et quelle est l'utilité de :
Code:

1 2 3 #include "ed/inc/prt.h" #if 1 #endif
07/06/2007, 09h47
Emmanuel Delahaye
Citation:

Envoyé par enzo_fxx

Pour la fonction init j'ai compis c'est la fonction put_dot et display que j'ai pas compris.

Bah, c'est juste une fonction d'affichage de la valeur des cartes, avec un mécanisme qui met un point a partir du 2ème champ.

Citation:

Et quelle est l'utilité de :

Code:

#include "ed/inc/prt.h"

Ignore cette ligne (survivance d'un code de debug personnel). Je l'ai retirée.
Citation:
Code:

1 2 3 #if 1 #endif
Compilation conditionnelle:
1 (ou autre chose <> 0) : ca compile
0 : ça compile pas.

Ca permet d'activer/désactiver une portion de code simplement et rapidement (sans effacer le code).
07/06/2007, 10h19
enzo_fxx

Quand je lance le programme il ne m'affiche pas les cartes basiques.

Je croie que j'ai trouvé il y avait "i" à la place de "j" pour la boucle des cartes basiques.

Code:

1
2
3
4
5
6
7
for (j = 0; i < 72; i++)
   {
      p_jeu->cartes[i].valeur = valeur[i % 9];
      p_jeu->cartes[i].joker = NULL;
      p_jeu->cartes[i].zero = NULL;
      p_jeu->cartes[i].couleur = couleur[i / (72 / 4)];
   }

Citation:

Envoyé par enzo_fxx

Quand je lance le programme il ne m'affiche pas les cartes basiques.

Avec le code que j'ai posté, j'obtiens ceci :

Code:

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
 
UN.BLEU
DEUX.BLEU
TROIS.BLEU
QUATRE.BLEU
CINQ.BLEU
SIX.BLEU
SEPT.BLEU
HUIT.BLEU
NEUF.BLEU
UN.BLEU
DEUX.BLEU
TROIS.BLEU
QUATRE.BLEU
CINQ.BLEU
SIX.BLEU
SEPT.BLEU
HUIT.BLEU
NEUF.BLEU
UN.ROUGE
DEUX.ROUGE
TROIS.ROUGE
QUATRE.ROUGE
CINQ.ROUGE
SIX.ROUGE
SEPT.ROUGE
HUIT.ROUGE
NEUF.ROUGE
UN.ROUGE
DEUX.ROUGE
TROIS.ROUGE
QUATRE.ROUGE
CINQ.ROUGE
SIX.ROUGE
SEPT.ROUGE
HUIT.ROUGE
NEUF.ROUGE
UN.VERT
DEUX.VERT
TROIS.VERT
QUATRE.VERT
CINQ.VERT
SIX.VERT
SEPT.VERT
HUIT.VERT
NEUF.VERT
UN.VERT
DEUX.VERT
TROIS.VERT
QUATRE.VERT
CINQ.VERT
SIX.VERT
SEPT.VERT
HUIT.VERT
NEUF.VERT
UN.JAUNE
DEUX.JAUNE
TROIS.JAUNE
QUATRE.JAUNE
CINQ.JAUNE
SIX.JAUNE
SEPT.JAUNE
HUIT.JAUNE
NEUF.JAUNE
UN.JAUNE
DEUX.JAUNE
TROIS.JAUNE
QUATRE.JAUNE
CINQ.JAUNE
SIX.JAUNE
SEPT.JAUNE
HUIT.JAUNE
NEUF.JAUNE
PLUSDEUX.BLEU
INVERSION.BLEU
PASSER_TOUR.BLEU
PLUSDEUX.BLEU
INVERSION.BLEU
PASSER_TOUR.BLEU
PLUSDEUX.ROUGE
INVERSION.ROUGE
PASSER_TOUR.ROUGE
PLUSDEUX.ROUGE
INVERSION.ROUGE
PASSER_TOUR.ROUGE
PLUSDEUX.VERT
INVERSION.VERT
PASSER_TOUR.VERT
PLUSDEUX.VERT
INVERSION.VERT
PASSER_TOUR.VERT
PLUSDEUX.JAUNE
INVERSION.JAUNE
PASSER_TOUR.JAUNE
PLUSDEUX.JAUNE
INVERSION.JAUNE
PASSER_TOUR.JAUNE
ZERO.BLEU
ZERO.ROUGE
ZERO.VERT
ZERO.JAUNE
 
Press ENTER to continue.

Il manque quelque chose ?

Salut,

Personnellement, afin d'éviter les problèmes lors de la distribution des cartes, dont le risque de voir une carte déjà distribuée/jouée à/par un joueur augmente en fonctions du nombre de cartes distribuées/jouées, à utiliser une liste, éventuellement rendue circulaire lors de la distribution...

le "sabot" contiendrait une liste circulaire contenant les cartes à distribuer et chaque joueur recevrait une liste, non circulaire, des cartes dont il dispose.

La structure serait alors sous la forme de
Code:

1 2 3 4 5 6 7 8 typedef struct s_carte { char *couleur; char *valeur; char *jokers; s_carte *suivante; } carte;
L'algorithme d'initialisation prendrait la forme de
Code:

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 carte *debut <-- NULL carte *fin <-- NULL POUR chaque couleur | POUR chaque valeur | | POUR i=1 à 2 | | | allouer carte | | | carte->couleur <-- couleur | | | carte->valeur <-- valeur | | | carte->joker <-- NULL | | | si debut = NULL | | | | debut <-- carte | | | FIN SI | | | SI fin <>NULL | | | | fin->suivant <-- carte | | | FIN SI | | | fin <-- carte | | FIN POUR | FIN POUR FIN POUR POUR chaque joker | allouer carte | carte->couleur <-- NULL | carte->valeur <-- NULL | carte->jocker <-- type joker | fin->suivant <-- carte | fin <-- carte FIN POUR (rendre la liste circulaire) fin->suivant <-- debut
L'algorithme de distribution serait proche de
("jeu" étant la liste circulaire créée par l'algorithme ci-dessus ;))
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 POUR i= 1 à nombre cartes par joueur | POUR chaque joueur | | alea <-- nombre aléatoire //début de la sélection aléatoire | | POUR j= 0 à alea | | | jeu <-- jeu suivant | | FIN POUR //fin de la selection aleatoire | | donne <-- jeu->suivant | | jeu->suivant <-- donne->suivant | | donne-> suivant <-- NULL | | joueur fin->suivant <-- donne | | joueur fin <-- donne | FIN POUR FIN POUR
L'algorithme pour qu'un joueur dépose une carte prendrait enfin la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 demander numero carte (éventuellement, lui remontrer la liste des cartes ;)) SI numero=0 //veut jouer la premiere de la liste | joue <-- debut | debut <-- joue->suivant | joue->suivant <-- NULL SINON | cherche <-- debut | POUR i=1 à numero | | cherche <-- cherche->suivant | FIN POUR | joue <-- cherche->suivant | cherche->suivant <-- joue->suivant | joue-> suivant <-- NULL FIN SI fin tas-> suivant <-- joue //ou fin tas est la fin de la liste des cartes jouées
J'ai peut etre passé une des regles... mais, voila le principe ;)

Citation:

Avec le code que j'ai posté, j'obtiens ceci :

Code:

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
UN.BLEU
DEUX.BLEU
TROIS.BLEU
QUATRE.BLEU
CINQ.BLEU
SIX.BLEU
SEPT.BLEU
HUIT.BLEU
NEUF.BLEU
UN.BLEU
DEUX.BLEU
TROIS.BLEU
QUATRE.BLEU
CINQ.BLEU
SIX.BLEU
SEPT.BLEU
HUIT.BLEU
NEUF.BLEU
UN.ROUGE
DEUX.ROUGE
TROIS.ROUGE
QUATRE.ROUGE
CINQ.ROUGE
SIX.ROUGE
SEPT.ROUGE
HUIT.ROUGE
NEUF.ROUGE
UN.ROUGE
DEUX.ROUGE
TROIS.ROUGE
QUATRE.ROUGE
CINQ.ROUGE
SIX.ROUGE
SEPT.ROUGE
HUIT.ROUGE
NEUF.ROUGE
UN.VERT
DEUX.VERT
TROIS.VERT
QUATRE.VERT
CINQ.VERT
SIX.VERT
SEPT.VERT
HUIT.VERT
NEUF.VERT
UN.VERT
DEUX.VERT
TROIS.VERT
QUATRE.VERT
CINQ.VERT
SIX.VERT
SEPT.VERT
HUIT.VERT
NEUF.VERT
UN.JAUNE
DEUX.JAUNE
TROIS.JAUNE
QUATRE.JAUNE
CINQ.JAUNE
SIX.JAUNE
SEPT.JAUNE
HUIT.JAUNE
NEUF.JAUNE
UN.JAUNE
DEUX.JAUNE
TROIS.JAUNE
QUATRE.JAUNE
CINQ.JAUNE
SIX.JAUNE
SEPT.JAUNE
HUIT.JAUNE
NEUF.JAUNE
PLUSDEUX.BLEU
INVERSION.BLEU
PASSER_TOUR.BLEU
PLUSDEUX.BLEU
INVERSION.BLEU
PASSER_TOUR.BLEU
PLUSDEUX.ROUGE
INVERSION.ROUGE
PASSER_TOUR.ROUGE
PLUSDEUX.ROUGE
INVERSION.ROUGE
PASSER_TOUR.ROUGE
PLUSDEUX.VERT
INVERSION.VERT
PASSER_TOUR.VERT
PLUSDEUX.VERT
INVERSION.VERT
PASSER_TOUR.VERT
PLUSDEUX.JAUNE
INVERSION.JAUNE
PASSER_TOUR.JAUNE
PLUSDEUX.JAUNE
INVERSION.JAUNE
PASSER_TOUR.JAUNE
ZERO.BLEU
ZERO.ROUGE
ZERO.VERT
ZERO.JAUNE
 
Press ENTER to continue.

Il manque quelque chose ?

Désolé je croie que c'est un probléme d'affichage sous BORLAND, sur DevC++ sa marche impec.

J'ai essayé de faire le mélange mais il me met une erreur, tu peut pas regarder mon programme.

Code:

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
 
#include <stdio.h>
#include <string.h>
#include <time.h>
 
typedef struct
{
   char const *valeur;
   char const *joker;
   char const *zero;
   char const *couleur;
}
carte_s;
 
typedef struct
{
   carte_s cartes[72 + 24 + 4];
}
uno_s;
 
void init (uno_s * p_jeu)
{
   char const *valeur[] =
      { "UN", "DEUX", "TROIS", "QUATRE", "CINQ", "SIX", "SEPT", "HUIT",
      "NEUF"
   };
   char const *joker[] = { "PLUSDEUX", "INVERSION", "PASSER_TOUR" };
   char const *zero[] = { "ZERO" };
   char const *couleur[] = { "BLEU", "ROUGE", "VERT", "JAUNE" };
 
   int i;
   int j;
 
/* 72 cartes basiques de 1 à 9 associés au couleurs */
   for (i = 0; i < 72; i++)
   {
      p_jeu->cartes[i].valeur = valeur[i % 9];
      p_jeu->cartes[i].joker = NULL;
      p_jeu->cartes[i].zero = NULL;
      p_jeu->cartes[i].couleur = couleur[i / (72 / 4)];
   }
 
/* 24 cartes jokers associés au couleurs */
   for (j = 0; i < 72 + 24; i++)
   {
      p_jeu->cartes[i].valeur = NULL;
      p_jeu->cartes[i].joker = joker[j % 3];
      p_jeu->cartes[i].zero = NULL;
      p_jeu->cartes[i].couleur = couleur[j / (24 / 4)];
      j++;
   }
 
/* 4 cartes zero de chaque couleur */
   for (j = 0; i < 72 + 24 + 4; i++)
   {
      p_jeu->cartes[i].valeur = NULL;
      p_jeu->cartes[i].joker = NULL;
      p_jeu->cartes[i].zero = zero[j % 1];
      p_jeu->cartes[i].couleur = couleur[j / (4 / 4)];
      j++;
   }
}
 
void melanger(uno_s * p_jeu)
{
int k,i,j,cpt=0;
randomize();
k=rand();
do
{
cpt++;
i=random(100);
j=random(100);
if(i<j)
permut(&(p_jeu->cartes[i]),&(p_jeu->cartes[j]));
else
permut(&p_jeu->cartes[i],&p_jeu->cartes[j]);
}while(cpt<k);
}
 
 
static int put_dot (char *s, int first)
{
   if (!first)
   {
      strcat (s, ".");
   }
   else
   {
      first = 0;
   }
   return first;
}
 
static void display (uno_s * p_jeu)
{
   int i;
 
   for (i = 0; i < 72 + 24 + 4; i++)
   {
      int first = 1;
      char s[128] = "";
 
      if (p_jeu->cartes[i].valeur != NULL)
      {
         first = put_dot (s, first);
         strcat (s, p_jeu->cartes[i].valeur);
      }
 
      if (p_jeu->cartes[i].joker != NULL)
      {
         first = put_dot (s, first);
         strcat (s, p_jeu->cartes[i].joker);
      }
 
      if (p_jeu->cartes[i].zero != NULL)
      {
         first = put_dot (s, first);
         strcat (s, p_jeu->cartes[i].zero);
      }
 
      if (p_jeu->cartes[i].couleur != NULL)
      {
         first = put_dot (s, first);
         strcat (s, p_jeu->cartes[i].couleur);
      }
 
      puts (s);
   }
}
 
int main (void)
{
   uno_s jeu[100];
   init (&jeu);
   melanger(&jeu)
   #if 1
   display (&jeu);
   #endif
   return 0;
 
}

Citation:
Envoyé par enzo_fxx
J'ai essayé de faire le mélange mais il me met une erreur, tu peut pas regarder mon programme.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 void melanger(uno_s * p_jeu) { int k,i,j,cpt=0; randomize(); k=rand(); do { cpt++; i=random(100); j=random(100); if(i<j) permut(&(p_jeu->cartes[i]),&(p_jeu->cartes[j])); else permut(&p_jeu->cartes[i],&p_jeu->cartes[j]); }while(cpt<k); }
Tu es obligé d'écrire ton code en vrac comme ça ? Tu ne vois pas que je fais des efforts de présentations ? Tu t'en tapes, c'est ça. "Démerdez vous avec mon code et le reste je m'en fous..."

Quel manque de respect pour ceux qui pourraient t'aider...

Et permut() ? On doit deviner ?

Voir 40 message(s) de cette discussion en une page