mastermind en C

mastermind en C - C - Programmation

Marsh Posté le 05-01-2012 à 15:19:23    

Bonjour à tous,
 
Pour mon projet de programmation, je dois réaliser le mastermind en C, je l'ai terminé et il n'y a pas d'erreur de compilation, seulement c'est impossible de gagner, quelque soit la combinaison que l'on rentre, le programme n'indique aucun point blanc ni noir, et je ne comprend pas d'où vient l'erreur .. Si quelqu'un pouvait m'éclairer et me dire quelle partie du code est incorrecte, ce serait vraiment sympa  :D  

Code :
  1. #include <stdio.h> // Fonctions getchar, printf()
  2. #include <stdlib.h> // Fonctions system()
  3. #include <string.h>
  4. #include <time.h>
  6. int menu();
  7. void jeu();
  8. void regles();
  9. // ---------------------------------------------------------------------------------------------------------------------------------------------
  10. void initCode(int *codeSecret);
  12. int main ()
  13. {
  15. int continuer = 1, choix = 0;
  16. int i;
  17.   int *codeSecret[4];
  18.  
  19.    
  21.   for(i=0; i<4; i++)
  22.     printf("%c", codeSecret[i]);
  24. while (continuer) //Tant que continuer vaut vrai (1)
  25. {
  26.     choix = menu();
  28.     switch (choix)
  29.     {
  30.         case 1:
  31.             jeu();
  32.         break;
  35.     // ----------------------------------
  37.         case 2:
  38.             regles();
  39.         break;
  41.     // ----------------------------------
  43.         case 3:
  44.             // Quitter
  45.             continuer = 0;
  46.             exit(-1);
  47.         break;
  49.     // ----------------------------------
  51.         default:
  52.             printf("Choix errone\n" );
  54.     }
  55.     // ----------------------------------
  56. } // while
  58. return 0;
  59. }
  61. // ------------------------------------------------------------------------------------------------------------------------------------------------
  62. int menu()
  63. {
  64.          int choix = 0;
  65.        
  66.          system("cls" ); // Nettoyer la console
  68.          printf("======== MENU ========\n\n" );
  69.          printf("(1) : Jouer\n" );
  70.          printf("(2) : Regles du jeu\n" );
  71.          printf("(3) : Quitter\n\n" );
  72.          printf("======================\n\n\n" );
  73.          printf("Que voulez vous faire ?\n\n" );
  74.          scanf("%d", &choix);
  75.        
  76.          return choix;
  77. }
  80. // ------------------------------------------------------------------------------------------------------------------------------------------
  81. void regles()
  82. {
  83.     int choix = 0;
  84.     system("cls" ); //Nettoyer la console
  85.    
  86.     //Affichage des règles du Mastermind
  87.     printf("***********************\n" );
  88.     printf("*REGLES DU MASTERMIND:*\n" );
  89.     printf("***********************\n" );
  90.    
  91.     printf("\nLe programme choisit une combinaison de 4 pions de couleurs au hasard\n" );
  92.     printf("parmi 6 couleurs disponibles.\n" );
  93.     printf("Cette combinaison de pions peut contenir plusieurs fois la meme couleur.\n" );
  94.     printf("L utilisateur essaie de la deviner en proposant au maximum dix combinaisons.\n" );
  95.     printf("Pour chaque tentative le programme indique le nombre de couleurs bien placees\n" );
  96.     printf("(a l aide de pion noir) et le nombre de couleurs mal placees\n" );
  97.     printf("(a l aide de pion blanc). Si le nombre maximal d essais est atteint,\n" );
  98.     printf("le programme indique au joueur qu il a perdu et donne la combinaison.\n\n" );
  99.     printf("------------------------------------------------------------------------------\n\n" );
  100.     printf("Entrez (0) pour revenir au menu principale\n" );
  101.     scanf("%d", &choix);
  102.    
  103.     if (choix == 0)
  104.     {
  105.         menu();
  106.     }
  107.     else
  108.     {
  109.         regles();
  110.     }   
  111.              
  112. }
  115. // ------------------------------------------------------------------------------------------------------------------------------------------
  116.     void jeu()
  117.     {
  119.         int essais=1,choix=0, ligne=9,continuer=1,verif=0,a; // "entrer" dans la boucle jeu
  120.         char tab[10][8]={
  121.                             {42,42,42,42,46,46,46,46},
  122.                             {42,42,42,42,46,46,46,46},
  123.                             {42,42,42,42,46,46,46,46},
  124.                             {42,42,42,42,46,46,46,46},
  125.                             {42,42,42,42,46,46,46,46},
  126.                             {42,42,42,42,46,46,46,46},
  127.                             {42,42,42,42,46,46,46,46},
  128.                             {42,42,42,42,46,46,46,46},
  129.                             {42,42,42,42,46,46,46,46},
  130.                             {42,42,42,42,46,46,46,46}
  131.                         };
  132.         char comb[4];
  134.                 system("cls" ); // Nettoyer la console
  136.                 // --------------------------------------------------------------------------------------------------------
  137. // Générer une combinaison aléatoire
  139. void initCode(int *codeSecret)
  140. {
  141. int i;
  143. srand (time(NULL));
  145. /* initialiser le code secret avec un choix de 6 couleurs */
  146. for (i = 0; i < 4 ; i++)
  147. {
  148.  switch (rand() % 6)
  149.  {
  150.   case 0: codeSecret[i] = 'r'; break;
  151.   case 1: codeSecret[i] = 'b'; break;
  152.   case 2: codeSecret[i] = 'v'; break;
  153.   case 3: codeSecret[i] = 'j'; break;
  154.   case 4: codeSecret[i] = 'o'; break;
  155.   case 5: codeSecret[i] = 'm'; break;
  156.  }
  157. } 
  158. }
  161. // -----------------------------------------------------------------------------------------------------------------------------------------------------
  163.             // Jeu du MASTERMIND
  166.             while (essais <= 10)
  167.             {
  169.                 int i, j, t, test=0, L=10, verif=0; // L : numéroter la ligne du tableau à partir de 10. ligne -> monter d'une ligne lorsque l'on entre une combinaison
  170.                 char rep[4]={'\0'};
  171.                 int a,b; // variable pour la vérification des combinaisons entrées
  173.                 system("cls" ); // Nettoyer la console
  175.                 printf("\nCouleurs disponibles : \n" );
  176.                 printf("=========================================================\n" );
  177.                 printf("r=Rouge - v=Vert - b=Bleu - j=Jaune - o=Orange - m=Marron \n" );
  178.                 printf("=========================================================\n\n" );
  181.                 // initialisation du tableau
  182.                 for (i=0;i<=9;i++)
  183.                 {
  184.                     printf ("[%3d]-[",L);
  186.                     for (j=0;j<=7;j++)
  187.                     {
  188.                         printf ("(%c)",tab[i][j]);
  189.                     }
  190.                     printf (" ]\n" );
  191.                     L--;
  192.                 }
  194.                 //printf("\n comb : %s",comb);
  196.             // --------------------------------------------------------------------------------------------------------
  198.                 // Entrer une combinaison
  199.                 while (verif != 4)
  200.                 {
  201.                     verif=0;
  202.                     printf("\n\nEssai n# %d: \n",essais);
  203.                     scanf("%s",&rep);
  204.                     fflush(stdin);
  206.                     // vérification de la combinaison entrée
  207.                     for (a=0;a<=3;a++)
  208.                     {
  209.                         if (rep[a]=='r' || rep[a]=='v' || rep[a]=='b' || rep[a]=='j' || rep[a]=='o' || rep[a]=='m' )
  210.                         {
  211.                             verif++;
  212.                         }
  213.                         else
  214.                         {
  215.                             verif--;
  216.                         }
  217.                     }
  218.                     if (verif !=4)
  219.                     {
  220.                         printf("\nCombinaison impossible. Recommencez !" );
  221.                     }
  222.                 }
  224.             // -----------------------------------------------------------------------------------------------------------
  225.                 // Ajout dans le combinaison dans le tableau
  227.                 test = strcmp(rep,comb); // on compare les 2 chaine de caractère, test sera négatif si s1 est < à s2, nul si s1 est == à s2 ou positif si s1 est > à s2
  228.                 if (test==0)
  229.                 {
  230.                     essais=11; // le joueur a trouvé la combinaison, on quitte la boucle jeu
  231.                 }
  232.                 else
  233.                 {
  234.                     for (j=0;j<=3;j++) // se déplacer de cellule en cellule
  235.                     {
  236.                         for (t=0;t<=3;t++) // permet de se déplacer dans la chaine de caractère comb, afin d'analyser chaque lettre
  237.                         {
  238.                             if (j == t) // si j == t, on est à la même position dans la chaine
  239.                             {
  240.                                 if (rep[j]==comb[t]) // Si le caractère n°x est égale au caractère n°x de la combinaison
  241.                                 {
  242.                                     tab[ligne][j]=rep[j];
  243.                                     tab[ligne][j+4]=78; // on affiche N (ascii 78)
  244.                                 }
  245.                             }
  246.                             else
  247.                             {
  248.                                 if (rep[j]==comb[t]) // Si le caractère n°x n'est pas égale au caractère n°x, mais qu'il figure dans la combinaison
  249.                                 {
  250.                                     tab[ligne][j]=rep[j];
  251.                                     tab[ligne][j+4]=66; // on affiche B (ascii 66)
  252.                                 }
  253.                                 else // Sinon on affiche un point
  254.                                 {
  255.                                     tab[ligne][j]=rep[j];
  256.                                     tab[ligne][j+4]=46; // on affiche un point (ascii 46)
  257.                                 }
  258.                             }
  259.                         }
  260.                     }
  261.                 }
  263.                 fflush(stdin);
  264.                 essais++;
  265.                 ligne--;
  266.             }
  268.             // ---------------------------------------------------------------------------------------
  269.             // Jeu terminé
  270.             if (essais == 12) // si essais == 12, alors le joueurs a trouvé la combinaison
  271.             {
  272.                 printf("Jeu termine" );
  273.                 printf("\n\n  ****** B R A V O *****\n" );
  274.                 printf("\n **!!! VOUS AVEZ TROUVE LA COMBINAISON !!!**\n" );
  275.                 printf("\n\n*********************************************************\n" );
  276.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  277.                 scanf ("%d",&choix);
  278.             }
  279.             else
  280.             {
  281.                 system("cls" ); // Nettoyer la console
  282.                 printf("Jeu termine" );
  283.                 printf("\n\n*********************************************************\n" );
  284.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  285.                 scanf ("%d",&choix);
  286.             }
  288.             // ---------------------------------------------------------------------------------------
  291.         if (choix == 0)
  292.         {
  293.             menu();
  294.         }
  295.         else
  296.         {
  297.             jeu();
  298.         }
  299.     }

Message cité 1 fois
Reply

Marsh Posté le 05-01-2012 à 15:19:23   

Reply

Marsh Posté le 07-01-2012 à 10:21:55    

fia123 a écrit :

Bonjour à tous,
 
Pour mon projet de programmation, je dois réaliser le mastermind en C, je l'ai terminé et il n'y a pas d'erreur de compilation, seulement c'est impossible de gagner, quelle que soit la combinaison que l'on rentre, le programme n'indique aucun point blanc ni noir, et je ne comprends pas d'où vient l'erreur .. Si quelqu'un pouvait m'éclairer et me dire quelle partie du code est incorrecte, ce serait vraiment sympa  :D


 
Salut
Bravo pour ton orthographe presque irréprochable. Comparé à ce que certains niaiseux écrivent ici, ça fait déjà plaisir à lire.
 
Bon maintenant voyons ce code...
 

fia123 a écrit :

Code :
  1. #include <stdio.h> // Fonctions getchar, printf()
  2. #include <stdlib.h> // Fonctions system()
  3. #include <string.h>
  4. #include <time.h>
  6. int menu();
  7. void jeu();
  8. void regles();
  9. // ---------------------------------------------------------------------------------------------------------------------------------------------
  10. void initCode(int *codeSecret);
  12. int main ()
  13. {
  15. int continuer = 1, choix = 0;
  16. int i;
  17. int *codeSecret[4]; // Pourquoi codeSecret est-il un tableau de 4 pointeurs ???
  18.  
  19.    
  21.   for(i=0; i<4; i++)
  22.     printf("%c", codeSecret[i]);
  24. while (continuer) //Tant que continuer vaut vrai (1) hum... des commentaires oui mais des commentaires intelligents !!! Expliquer par exemple quelle va être l'action du bout de code. Traduire en français une instruction C n'est pas très utile...
  25. {
  26.     choix = menu();
  28.     switch (choix)
  29.     {
  30.         case 1:
  31.             jeu();
  32.         break;
  35.     // ----------------------------------
  37.         case 2:
  38.             regles();
  39.         break;
  41.     // ----------------------------------
  43.         case 3:
  44.             // Quitter
  45.             continuer = 0;
  46.             exit(-1);   // Inutile ici (et de façon générale mettre un exit (en dehors d'un debug) est souvent synonyme de mauvaise conception
  47.         break;
  49.     // ----------------------------------
  51.         default:
  52.             printf("Choix errone\n" );
  54.     }
  55.     // ----------------------------------
  56. } // while
  58. return 0;
  59. }
  61. // ------------------------------------------------------------------------------------------------------------------------------------------------
  62. int menu()
  63. {
  64.          int choix = 0;
  65.        
  66.          system("cls" ); // Nettoyer la console
  68.          printf("======== MENU ========\n\n" );
  69.          printf("(1) : Jouer\n" );
  70.          printf("(2) : Regles du jeu\n" );
  71.          printf("(3) : Quitter\n\n" );
  72.          printf("======================\n\n\n" );
  73.          printf("Que voulez vous faire ?\n\n" );
  74.          scanf("%d", &choix);
  75.        
  76.          return choix;
  77. }
  80. // ------------------------------------------------------------------------------------------------------------------------------------------
  81. void regles()
  82. {
  83.     int choix = 0;
  84.     system("cls" ); //Nettoyer la console
  85.    
  86.     //Affichage des règles du Mastermind
  87.     printf("***********************\n" );
  88.     printf("*REGLES DU MASTERMIND:*\n" );
  89.     printf("***********************\n" );
  90.    
  91.     printf("\nLe programme choisit une combinaison de 4 pions de couleurs au hasard\n" );
  92.     printf("parmi 6 couleurs disponibles.\n" );
  93.     printf("Cette combinaison de pions peut contenir plusieurs fois la meme couleur.\n" );
  94.     printf("L utilisateur essaie de la deviner en proposant au maximum dix combinaisons.\n" );
  95.     printf("Pour chaque tentative le programme indique le nombre de couleurs bien placees\n" );
  96.     printf("(a l aide de pion noir) et le nombre de couleurs mal placees\n" );
  97.     printf("(a l aide de pion blanc). Si le nombre maximal d essais est atteint,\n" );
  98.     printf("le programme indique au joueur qu il a perdu et donne la combinaison.\n\n" );
  99.     printf("------------------------------------------------------------------------------\n\n" );
  100.     printf("Entrez (0) pour revenir au menu principale\n" );
  101.     scanf("%d", &choix);
  102.    
  103.     if (choix == 0)
  104.     {
  105.         menu();
  106.     }
  107.     else
  108.     {
  109.         regles();  // OUCH !!! Tu n'as rien trouvé de mieux que de la récursivité pour programmer une boucle ??? Tu n'as pas l'impression que "récursivité" implique quelque part "mécanisme d'empilement des couches successives" ???
  110.     }   
  111.              
  112. }
  115. // ------------------------------------------------------------------------------------------------------------------------------------------
  116.     void jeu()
  117.     {
  119.         int essais=1,choix=0, ligne=9,continuer=1,verif=0,a; // "entrer" dans la boucle jeu
  120.         char tab[10][8]={
  121.                             {42,42,42,42,46,46,46,46},
  122.                             {42,42,42,42,46,46,46,46},
  123.                             {42,42,42,42,46,46,46,46},
  124.                             {42,42,42,42,46,46,46,46},
  125.                             {42,42,42,42,46,46,46,46},
  126.                             {42,42,42,42,46,46,46,46},
  127.                             {42,42,42,42,46,46,46,46},
  128.                             {42,42,42,42,46,46,46,46},
  129.                             {42,42,42,42,46,46,46,46},
  130.                             {42,42,42,42,46,46,46,46}
  131.                         };    //Pourquoi ces valeurs 42 et 46
  132.         char comb[4];
  134.                 system("cls" ); // Nettoyer la console
  136.                 // --------------------------------------------------------------------------------------------------------
  137. // Générer une combinaison aléatoire
  139. // J'ai dû rater un truc. On est bien dans la fonction jeu() non ???
  140. void initCode(int *codeSecret)
  141. {
  142. int i;
  144. srand (time(NULL));  //Le srand() est un outil d'initialisation. Comme tel, il ne doit être exécuté qu'une seule fois dans le programme et non à chaque fois que la fonction est appelée.
  146. /* initialiser le code secret avec un choix de 6 couleurs */
  147. for (i = 0; i < 4 ; i++)
  148. {
  149.  switch (rand() % 6)
  150.  {
  151.   case 0: codeSecret[i] = 'r'; break;
  152.   case 1: codeSecret[i] = 'b'; break;
  153.   case 2: codeSecret[i] = 'v'; break;
  154.   case 3: codeSecret[i] = 'j'; break;
  155.   case 4: codeSecret[i] = 'o'; break;
  156.   case 5: codeSecret[i] = 'm'; break;
  157.  }
  158. } 
  159. }
  162. // -----------------------------------------------------------------------------------------------------------------------------------------------------
  164.             // Jeu du MASTERMIND
  167.             while (essais <= 10)
  168.             {
  170.                 int i, j, t, test=0, L=10, verif=0; // L : numéroter la ligne du tableau à partir de 10. ligne -> monter d'une ligne lorsque l'on entre une combinaison
  171.                 char rep[4]={'\0'};    // char rep[4]=""
  172.                 int a,b; // variable pour la vérification des combinaisons entrées
  174.                 system("cls" ); // Nettoyer la console
  176.                 printf("\nCouleurs disponibles : \n" );
  177.                 printf("=========================================================\n" );
  178.                 printf("r=Rouge - v=Vert - b=Bleu - j=Jaune - o=Orange - m=Marron \n" );
  179.                 printf("=========================================================\n\n" );
  182.                 // initialisation du tableau
  183.                 for (i=0;i<=9;i++)
  184.                 {
  185.                     printf ("[%3d]-[",L);
  187.                     for (j=0;j<=7;j++)
  188.                     {
  189.                         printf ("(%c)",tab[i][j]);
  190.                     }
  191.                     printf (" ]\n" );
  192.                     L--;
  193.                 }
  195.                 //printf("\n comb : %s",comb);
  197.             // --------------------------------------------------------------------------------------------------------
  199.                 // Entrer une combinaison
  200.                 while (verif != 4)
  201.                 {
  202.                     verif=0;
  203.                     printf("\n\nEssai n# %d: \n",essais);
  204.                     scanf("%s",&rep);   //rep est déjà un pointeur !!!
  205.                     fflush(stdin);
  207.                     // vérification de la combinaison entrée
  208.                     for (a=0;a<=3;a++)    // for (a=0; a < 4; a++) => la lisibilité d'un code ce n'est pas seulement mettre des commentaires ; c'est aussi garder une certaine cohérence. Puisque rep est défini comme tab[4] alors autant réutiliser cette valeur "4"
  209.                     {
  210.                         if (rep[a]=='r' || rep[a]=='v' || rep[a]=='b' || rep[a]=='j' || rep[a]=='o' || rep[a]=='m' )
  211.                         {
  212.                             verif++;
  213.                         }
  214.                         else
  215.                         {
  216.                             verif--;
  217.                         }
  218.                     }
  219.                     if (verif !=4)
  220.                     {
  221.                         printf("\nCombinaison impossible. Recommencez !" );
  222.                     }
  223.                 }
  225.             // -----------------------------------------------------------------------------------------------------------
  226.                 // Ajout dans le combinaison dans le tableau
  228.                 test = strcmp(rep,comb); // on compare les 2 chaine de caractère, test sera négatif si s1 est < à s2, nul si s1 est == à s2 ou positif si s1 est > à s2 Et où a été rempli comb ??? D'ailleurs je ne vois plus trop ce qu'est devenu ce fameux tableau de 4 pointeurs "codeSecret"...?
  229.                 if (test==0)
  230.                 {
  231.                     essais=11; // le joueur a trouvé la combinaison, on quitte la boucle jeu
  232.                 }
  233.                 else
  234.                 {
  235.                     for (j=0;j<=3;j++) // se déplacer de cellule en cellule
  236.                     {
  237.                         for (t=0;t<=3;t++) // permet de se déplacer dans la chaine de caractère comb, afin d'analyser chaque lettre
  238.                         {
  239.                             if (j == t) // si j == t, on est à la même position dans la chaine
  240.                             {
  241.                                 if (rep[j]==comb[t]) // Si le caractère n°x est égale au caractère n°x de la combinaison
  242.                                 {
  243.                                     tab[ligne][j]=rep[j];
  244.                                     tab[ligne][j+4]=78; // on affiche N (ascii 78)  ????? tab[ligne][j+4]='N' !!!
  245.                                 }
  246.                             }
  247.                             else
  248.                             {
  249.                                 if (rep[j]==comb[t]) // Si le caractère n°x n'est pas égale au caractère n°x, mais qu'il figure dans la combinaison
  250.                                 {
  251.                                     tab[ligne][j]=rep[j];
  252.                                     tab[ligne][j+4]=66; // on affiche B (ascii 66) oui oui
  253.                                 }
  254.                                 else // Sinon on affiche un point
  255.                                 {
  256.                                     tab[ligne][j]=rep[j];
  257.                                     tab[ligne][j+4]=46; // on affiche un point (ascii 46) oui oui
  258.                                 }
  259.                             }
  260.                         }
  261.                     }
  262.                 }
  264.                 fflush(stdin);    // NON !!! fflush() est interdit sur stdin - Si ton buffer clavier a des caractères en trop c'est dû aux scanf() mal employés (ou employés à tort)
  265.                 essais++;
  266.                 ligne--;
  267.             }
  269.             // ---------------------------------------------------------------------------------------
  270.             // Jeu terminé
  271.             if (essais == 12) // si essais == 12, alors le joueurs a trouvé la combinaison
  272.             {
  273.                 printf("Jeu termine" );
  274.                 printf("\n\n  ****** B R A V O *****\n" );
  275.                 printf("\n **!!! VOUS AVEZ TROUVE LA COMBINAISON !!!**\n" );
  276.                 printf("\n\n*********************************************************\n" );
  277.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  278.                 scanf ("%d",&choix);
  279.             }
  280.             else
  281.             {
  282.                 system("cls" ); // Nettoyer la console
  283.                 printf("Jeu termine" );
  284.                 printf("\n\n*********************************************************\n" );
  285.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  286.                 scanf ("%d",&choix);
  287.             }
  289.             // ---------------------------------------------------------------------------------------
  292.         if (choix == 0)
  293.         {
  294.             menu();
  295.         }
  296.         else
  297.         {
  298.             jeu();  //Oui, quand une solution fonctionne alors autant l'employer de partout !!!
  299.         }
  300.     }



 
Bon ben j'ai mis en rouge tout ce qui ne va pas dans ton code. Certaines erreurs ne sont pas la cause de ce que ça ne marche pas mais toutes sont préjudiciables à plus ou moins long terme.
 
Ensuite c'est bien de découper en fonctions mais pourquoi ne faire que la moitié du travail ? Faut essayer de repérer les phases importantes et les attribuer à des fonctions dédiées. Par exemple je verrais bien une fonction dédiée à la phase de comparaison du jeu et de la solution...


Message édité par Sve@r le 07-01-2012 à 10:44:59
Reply

Marsh Posté le 08-01-2012 à 01:06:51    

Sve@r,
Merci pour ta réponse très claire et détaillée, seulement depuis la publication de mon message j'ai considérablement changé mon code et maintenant il fonctionne bien. Le voici :

Code :
  1. #include <stdio.h> // Fonctions getchar, printf()
  2. #include <stdlib.h> // Fonctions system()
  3. #include <string.h>
  4. #include <time.h>
  6. #define OK 1
  8. int menu();
  9. void jeu();
  10. void regles();
  11. // ---------------------------------------------------------------------------------------------------------------------------------------------
  12. void initCode(char *codeSecret);
  13. void analyserCombinaison(char *comb, char *rep, char *resultat);
  15. int main ()
  16. {
  18. int continuer = 1, choix = 0;
  21. while (continuer) // Boucle permettant de choisir ce que l'on veut faire dans le programme
  22. {
  23.     choix = menu();
  25.     switch (choix)
  26.     {
  27.         case 1:
  28.             jeu();
  29.         break;
  32.     // ----------------------------------
  34.         case 2:
  35.             regles();
  36.         break;
  38.     // ----------------------------------
  40.         case 3:
  41.             // Quitter
  42.             continuer = 0;
  43.         break;
  45.     // ----------------------------------
  47.         default:
  48.             printf("Choix errone\n" );
  50.     }
  51.     // ----------------------------------
  52. } // while
  54. return 0;
  55. }
  57. // ------------------------------------------------------------------------------------------------------------------------------------------------
  58. int menu()
  59. {
  60.          int choix = 0;
  61.        
  62.          system("cls" ); // Nettoyer la console
  64.          printf("======== MENU ========\n\n" );
  65.          printf("(1) : Jouer\n" );
  66.          printf("(2) : Regles du jeu\n" );
  67.          printf("(3) : Quitter\n\n" );
  68.          printf("======================\n\n\n" );
  69.          printf("Que voulez vous faire ?\n\n" );
  70.          scanf("%d", &choix);
  71.        
  72.          return choix;
  73. }
  76. // ------------------------------------------------------------------------------------------------------------------------------------------
  77. void regles()
  78. {
  79.     int choix = 0;
  80.     system("cls" ); //Nettoyer la console
  81.    
  82.     //Affichage des règles du Mastermind
  83.     printf("***********************\n" );
  84.     printf("*REGLES DU MASTERMIND:*\n" );
  85.     printf("***********************\n" );
  86.    
  87.     printf("\nLe programme choisit une combinaison de 4 pions de couleurs au hasard\n" );
  88.     printf("parmi 6 couleurs disponibles.\n" );
  89.     printf("Cette combinaison de pions peut contenir plusieurs fois la meme couleur.\n" );
  90.     printf("L utilisateur essaie de la deviner en proposant au maximum dix combinaisons.\n" );
  91.     printf("Pour chaque tentative le programme indique le nombre de couleurs bien placees\n" );
  92.     printf("(a l aide de pion noir) et le nombre de couleurs mal placees\n" );
  93.     printf("(a l aide de pion blanc). Si le nombre maximal d essais est atteint,\n" );
  94.     printf("le programme indique au joueur qu il a perdu et donne la combinaison.\n\n" );
  95.     printf("------------------------------------------------------------------------------\n\n" );
  96.     printf("Entrez (0) pour revenir au menu principale\n" );
  97.     scanf("%d", &choix);
  98.    
  99.     if (choix == 0)
  100.     {
  101.         menu();
  102.     }
  103.     else
  104.     {
  105.         regles(); // Sve@r, j'avoue ne pas avoir très bien compris ton commentaire pour cette ligne de code .. je ne vois pas le problème.
  106.     }   
  107.              
  108. }
  110.     void verifierCombi(char *comb, char *rep, char *resultat) //Permet de tester la combinaison entrée par le joueur pour voir si elle est sous la bonne forme.
  111.     {
  112.     char repMinuscule[4];
  113.     int a;
  114.     for(a=0;a<4;a++)
  115.     {
  116.      repMinuscule[a]=tolower(rep[a]); //Permet de transformer une majuscule en minuscule, ce qui permettra d'enter à la fois des minuscules et des majuscules comme combinaison
  117.      }
  118.    
  119.     int controle[4] = {0,0,0,0};//sert à vérifier s'il n'y a pas un N à cette position
  120.     int j=0;
  121.     int i;
  122.          for( i = 0;i<4;i++)//Sert à détecter les pions noirs
  123.          {
  124.              if (repMinuscule[i]==comb[i])
  125.              {
  126.               resultat[j] = 'N';
  127.               j++;
  128.               controle[i] = OK; 
  129.              }         
  130.          } 
  131.        
  132.          for(i = 0;i<4;i++)//Sert à détecter les pions blancs
  133.          {
  134.                  if(controle[i]!=OK)
  135.                  {
  136.                        int k;
  137.                        for(k=0;k<4;k++)
  138.                        {
  139.                                if (repMinuscule[k]==comb[i] && controle[i]!=OK)
  140.                                {
  141.                                 resultat[j]= 'B';
  142.                                 j++;
  143.                                 controle[i] = OK;
  144.                                }
  145.                                      
  146.                        }
  147.                  }
  148.          }
  149.     }
  150. void initCode(char *codeSecret) //Fonction permettant de générer un code de 4 couleurs avec les initiales des 6 couleurs proposées.
  151. {
  152. int i;
  154. srand (time(NULL));
  156. /* initialiser le code secret avec un choix de 6 couleurs */
  157. for (i = 0; i < 4 ; i++)
  158. {
  159.  switch (rand() % 6)
  160.  {
  161.   case 0: codeSecret[i] = 'r'; break;
  162.   case 1: codeSecret[i] = 'b'; break;
  163.   case 2: codeSecret[i] = 'v'; break;
  164.   case 3: codeSecret[i] = 'j'; break;
  165.   case 4: codeSecret[i] = 'o'; break;
  166.   case 5: codeSecret[i] = 'm'; break;
  167.  }
  168. } 
  169. }
  172. // ------------------------------------------------------------------------------------------------------------------------------------------
  173.     void jeu()
  174.     {
  176.         int essais=0,choix=0, ligne=9,continuer=1,verif=0,a; // "entrer" dans la boucle jeu
  177.         char tab[10][8]={
  178.                             {42,42,42,42,46,46,46,46},
  179.                             {42,42,42,42,46,46,46,46},
  180.                             {42,42,42,42,46,46,46,46},
  181.                             {42,42,42,42,46,46,46,46},
  182.                             {42,42,42,42,46,46,46,46},
  183.                             {42,42,42,42,46,46,46,46},
  184.                             {42,42,42,42,46,46,46,46},
  185.                             {42,42,42,42,46,46,46,46},//Sv@r, 42:*  46:.  j'initialise les valeurs de mon tableau avec ces 2 éléments
  186.                             {42,42,42,42,46,46,46,46},
  187.                             {42,42,42,42,46,46,46,46}
  188.                         };
  189.         char comb[5];
  190.         initCode(comb);
  191.                 system("cls" ); // Nettoyer la console
  193. // -----------------------------------------------------------------------------------------------------------------------------------------------------
  195.             // Jeu du MASTERMIND
  197.             char rep[5]={'\0'};
  198.             while (essais <= 10)
  199.             {
  200.                 char resultat[4]={46,46,46,46};
  201.                 int i, j, t, test=0, L=1, verif=0; // L : numéroter la ligne du tableau à partir de 10. ligne -> monter d'une ligne lorsque l'on entre une combinaison
  202.                
  203.                 int a,b; // variable pour la vérification des combinaisons entrées
  205.                 system("cls" ); // Nettoyer la console
  207.                 printf("\nCouleurs disponibles : \n" );
  208.                 printf("=========================================================\n" );
  209.                 printf("r=Rouge - v=Vert - b=Bleu - j=Jaune - o=Orange - m=Marron \n" );
  210.                 printf("=========================================================\n\n" );
  213.                 // affichage du tableau
  214.                 for (i=0;i<=9;i++)
  215.                 {
  216.                     printf ("[%3d]-[",L);
  218.                     for (j=0;j<=7;j++)
  219.                     {
  220.                         printf ("(%c)",tab[i][j]);
  221.                     }
  222.                     printf (" ]\n" );
  223.                     L++;
  224.                 }
  225.                 //printf("\n Les caracteres saisit sont: %c%c%c%c", rep[0],rep[1],rep[2],rep[3]);
  226.                 //printf("\n comb : %c%c%c%c",comb[0],comb[1],comb[2],comb[3]);
  228.             // --------------------------------------------------------------------------------------------------------
  230.                 // Entrer une combinaison
  231.                 while (verif != 4)
  232.                 {
  233.                     verif=0;
  234.                     printf("\n\nEssai n# %d: \n",essais);
  235.                     scanf("%s",&rep);
  236.                     fflush(stdin); /*j'ai essayé en utilisant a la place while(fgetc(stdin)!=EOF); mais le problème est qu'alors la combinaison que je rentre ne s'introduit plus dans le tableau .. */
  238.                     // vérification de la combinaison entrée
  239.                     for (a=0;a<=3;a++)
  240.                     {
  241.                         if (rep[a]=='r' || rep[a]=='v' || rep[a]=='b' || rep[a]=='j' || rep[a]=='o' || rep[a]=='m' || rep[a]=='R' || rep[a]=='V' || rep[a]=='B' || rep[a]=='J' || rep[a]=='O' || rep[a]=='M' )
  242.                         {
  243.                             verif++;
  244.                         }
  245.                         else
  246.                         {
  247.                             verif--;
  248.                         }
  249.                     }
  250.                     if (verif !=4)
  251.                     {
  252.                         printf("\nCombinaison impossible. Recommencez !" );
  253.                     }
  254.                 }
  255.                
  256.                
  257.                 verifierCombi(comb,rep,resultat);
  258.                
  259.                
  260.                 tab[essais][0]=rep[0];
  261.                 tab[essais][1]=rep[1];
  262.                 tab[essais][2]=rep[2];
  263.                 tab[essais][3]=rep[3];
  264.                 tab[essais][4]=resultat[0];
  265.                 tab[essais][5]=resultat[1];
  266.                 tab[essais][6]=resultat[2];
  267.                 tab[essais][7]=resultat[3];
  268.              
  269.               if (resultat[0]=='N' && resultat[1]=='N' && resultat[2]=='N' && resultat[3]=='N')// Si 4 'N' alors le joueur a trouvé le code secret
  270.                 {
  271.                    essais=99;
  272.                                      }
  273.                 else{
  274.                      essais++;
  275.                 }
  276.     }           
  277.                
  278.                
  279.             // ---------------------------------------------------------------------------------------
  280.             // Jeu terminé
  281.             if (essais == 99) // si essais == 99, alors le joueurs a trouvé la combinaison
  282.             {
  283.                 printf("Jeu termine" );
  284.                 printf("\n\n  ****** B R A V O *****\n" );
  285.                 printf("\n **!!! VOUS AVEZ TROUVE LA COMBINAISON !!!**\n" );
  286.                 printf("\n\n*********************************************************\n" );
  287.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  288.                 scanf ("%d",&choix);
  289.             }
  290.             else
  291.             {
  292.                 system("cls" ); // Nettoyer la console
  293.                 printf("Jeu termine" );
  294.                 printf("\n\n*********************************************************\n" );
  295.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  296.                 scanf ("%d",&choix);
  297.             }
  299.             // ---------------------------------------------------------------------------------------
  302.         if (choix == 0)
  303.         {
  304.             menu();
  305.         }
  306.         else
  307.         {
  308.             jeu();
  309.         }
  310.  
  311. }
 

Si tu pouvais me donner ton avis et me dire si il est préférable que je change certaines partie de mon code, ce serait vraiment super  :) (je tiens à re-préciser qu'il fonctionne correctement mais il n'est certainement pas parfait).

Message cité 1 fois
Message édité par fia123 le 08-01-2012 à 01:31:38
Reply

Marsh Posté le 08-01-2012 à 03:06:05    

fia123 a écrit :

Sve@r,
Merci pour ta réponse très claire et détaillée, seulement depuis la publication de mon message j'ai considérablement changé mon code et maintenant il fonctionne bien. Si tu pouvais me donner ton avis et me dire si il est préférable que je change certaines partie de mon code, ce serait vraiment super  :) (je tiens à re-préciser qu'il fonctionne correctement mais il n'est certainement pas parfait).


Il fonctionne oui. Mais "correctement"...
 
1) Concernant ton commentaire à propos de ma remarque: ta boucle principale affiche un menu. De ce menu on peut afficher les règles. Et les règles réaffichent les règles. Et les règles réaffichent les règles. Et etc etc. Pourtant tu as appris le principe d'imbrication des fonctions. Si une fonction A appelle une fonction B qui appelle une fonction C alors ensuite la C doit remonter vers la B qui remonte vers la A. Donc tu dis "tu ne vois pas ..." mais tu n'as rien fait pour "voir".
Rajoute printf("Fin de fonction\n" ) à la dernière ligne de la fonction "regles()" puis lance ton programme. Tape "2" pour avoir les règles puis, de là, tape encore cinq ou six fois "2" avant de taper "0". Là ca réaffichera le menu (bien inutilement d'ailleurs puisque ensuite la fonction se terminera et la boucle du main() réaffichera le menu) mais j'espère que là tu "verras" ce qui ne va pas...
 
2) Concernant les valeurs 42 et 46 ta réponse est vraiment crétine. Je te demande pourquoi tu initialises avec 42 et 46 et tu me réponds "j'initialise avec 42 et 46" !!!
 
3) pour vérifier que la réponse est acceptable c'est quoi tout ce micmac avec verif++ et verif-- ? Considère qu'elle l'est par défaut puis vérifie avec une boucle s'il y a un élément qui ne va pas. A la fin de la boucle, si ton verif est resté dans le même état qu'au début de la boucle ça veut dire que la réponse est acceptable.
 
4) je ne vois pas trop à quoi sert le tableau "controle". Si tu veux vérifier qu'il n'y a pas de "N" dans la case "resultat[x]" ben va regarder la valeur de cette case !!!
 
5) t'as rien fait de mes remarques dans les lignes 100, 144, 171 et surtout 204 de mon premier post
 
6) concernant le fflush(stdin) tu le supprimes. Mais chaque fois que tu utilises scanf() pour faire saisir un nombre (%d ou %f), un caractère (%x) alors tu rajoutes un fgetc(stdin) juste après. Mais si tu fais saisir une chaine (%s) alors surtout pas. Ce fgetc() sert à supprimer le '\n' représentant l'appui sur la touche <entrée> qui n'est pas vidé de stdin dans les 3 cas précités. Car quoi qu'il en soit tu appuies toujours sur cette touche à chaque saisie mais si scanf() attend un nombre ou un caractère alors cette touche appuyée reste dans stdin. Et si scanf() attend une chaine alors cette touche est intégrée à la chaine saisie.
 
Et si tu veux remplacer scanf (qui signifie "saisie formatée" et que ce que tape un humain est tout sauf formaté) par un outil de saisie plus robuste, alors essaye de tester et de t'inspirer de ce petit bout de code

Code :
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int x, y;
  6.     char chaine[50];
  8.     while(1)
  9.     {
  10.         printf("Entrez deux nombres séparés par un (ou plusieurs) espace\n" );
  11.         fgets(chaine, 50, stdin);
  12.         if (sscanf(chaine, "%d %d", &x, &y) == 2) break;
  14.         printf("Erreur sur l'un des deux nombres\n" );
  15.     }
  16.     printf("Vous avez entré %d et %d\n", x, y);
  17. }


 
Sinon pour le reste ben c'est encore brouillon mais ça peut attendre...


Message édité par Sve@r le 08-01-2012 à 03:15:40
Reply

Marsh Posté le 08-01-2012 à 15:01:13    

Sve@r, dans la table ascii, 42 correspond à "*" et 46 à "." je l'ai mis dans mon commentaire si tu regardes bien, j'initialise mon tableau avec des "*" et des ".".
Les "*" sont remplacés par les combinaisons que rentre le joueur, et les "." sont remplacés par les pions noirs ou blancs. Donc ma réponse n'étais pas "crétine". Pour ce qui est du reste, je te remercie toujours autant pour tes réponses détaillées, je vais modifier mon code ce soir. Merci.

Message cité 1 fois
Reply

Marsh Posté le 08-01-2012 à 16:56:09    

fia123 a écrit :

Sve@r, dans la table ascii, 42 correspond à "*" et 46 à "." je l'ai mis dans mon commentaire si tu regardes bien, j'initialise mon tableau avec des "*" et des ".".
Les "*" sont remplacés par les combinaisons que rentre le joueur, et les "." sont remplacés par les pions noirs ou blancs. Donc ma réponse n'étais pas "crétine".


Mais si ta réponse était crétine parce que tu ne sais pas lire entre les lignes. Je cherchais par cette motivation faite à ton amour propre que tu déduises de mes autres commentaires ce que j'aurais aimé que tu comprennes toute seule (me démontrant ainsi que tu savais aussi te servir de ta tête). Je sais bien que 42 et 46 représentent les caractères '*' et '.' mais pourquoi n'utilises-tu justement pas cette notation standard '*' et '.' ? Je t'avais pourtant signalé la chose en ligne 244 dans mon premier post !!!
 
En plus aujourd'hui tu travailles en ascii mais que se passera-t-il si demain tu travailles en utf-8 ? Tu crois que 42 et 46 auront la même signification ?

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed