UNO en langage C [Non suivi]

**enzo_fxx** · 02/06/2007, 20h33

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

**enzo_fxx** · 03/06/2007, 16h53

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 :

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
#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");
}

**Emmanuel Delahaye** · 03/06/2007, 17h04

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().

**Emmanuel Delahaye** · 03/06/2007, 17h06

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.

**enzo_fxx** · 04/06/2007, 12h36

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

Code :

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

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];
  }

**Emmanuel Delahaye** · 04/06/2007, 12h50

Envoyé par enzo_fxx

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

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
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 ?

**enzo_fxx** · 04/06/2007, 13h13

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

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
 
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...]

**Emmanuel Delahaye** · 04/06/2007, 13h37

Envoyé par enzo_fxx

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

Code :

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

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 :

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
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).

**enzo_fxx** · 07/06/2007, 00h27

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.

**Emmanuel Delahaye** · 07/06/2007, 02h13

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 ?

**enzo_fxx** · 07/06/2007, 10h00

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 :

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

1
2
3
#include "ed/inc/prt.h"
#if 1
#endif

**Emmanuel Delahaye** · 07/06/2007, 10h47

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.

Et quelle est l'utilité de :

Code :

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

#include "ed/inc/prt.h"

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

Code :

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

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).

**enzo_fxx** · 07/06/2007, 11h19

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

**enzo_fxx** · 07/06/2007, 11h29

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

Code :

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

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)];
   }

**Emmanuel Delahaye** · 07/06/2007, 12h52

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 :

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
 
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 ?

**koala01** · 07/06/2007, 14h19

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 :

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

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 :

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
 
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 :

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

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 :

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
 
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

**enzo_fxx** · 07/06/2007, 20h05

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

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
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.

**enzo_fxx** · 08/06/2007, 20h28

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

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
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;
 
}

**Emmanuel Delahaye** · 08/06/2007, 20h48

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 :

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
 
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 ?

UNO en langage C [Non suivi]

C

Discussions similaires

Partager

Partager