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>
  5. int menu();
  6. void jeu();
  7. void regles();
  8. // ---------------------------------------------------------------------------------------------------------------------------------------------
  9. void initCode(int *codeSecret);
  10. int main ()
  11. {
  12. int continuer = 1, choix = 0;
  13. int i;
  14.   int *codeSecret[4];
  15.  
  16.    
  17.   for(i=0; i<4; i++)
  18.     printf("%c", codeSecret[i]);
  19. while (continuer) //Tant que continuer vaut vrai (1)
  20. {
  21.     choix = menu();
  22.     switch (choix)
  23.     {
  24.         case 1:
  25.             jeu();
  26.         break;
  27.     // ----------------------------------
  28.         case 2:
  29.             regles();
  30.         break;
  31.     // ----------------------------------
  32.         case 3:
  33.             // Quitter
  34.             continuer = 0;
  35.             exit(-1);
  36.         break;
  37.     // ----------------------------------
  38.         default:
  39.             printf("Choix errone\n" );
  40.     }
  41.     // ----------------------------------
  42. } // while
  43. return 0;
  44. }
  45. // ------------------------------------------------------------------------------------------------------------------------------------------------
  46. int menu()
  47. {
  48.          int choix = 0;
  49.        
  50.          system("cls" ); // Nettoyer la console
  51.          printf("======== MENU ========\n\n" );
  52.          printf("(1) : Jouer\n" );
  53.          printf("(2) : Regles du jeu\n" );
  54.          printf("(3) : Quitter\n\n" );
  55.          printf("======================\n\n\n" );
  56.          printf("Que voulez vous faire ?\n\n" );
  57.          scanf("%d", &choix);
  58.        
  59.          return choix;
  60. }
  61. // ------------------------------------------------------------------------------------------------------------------------------------------
  62. void regles()
  63. {
  64.     int choix = 0;
  65.     system("cls" ); //Nettoyer la console
  66.    
  67.     //Affichage des règles du Mastermind
  68.     printf("***********************\n" );
  69.     printf("*REGLES DU MASTERMIND:*\n" );
  70.     printf("***********************\n" );
  71.    
  72.     printf("\nLe programme choisit une combinaison de 4 pions de couleurs au hasard\n" );
  73.     printf("parmi 6 couleurs disponibles.\n" );
  74.     printf("Cette combinaison de pions peut contenir plusieurs fois la meme couleur.\n" );
  75.     printf("L utilisateur essaie de la deviner en proposant au maximum dix combinaisons.\n" );
  76.     printf("Pour chaque tentative le programme indique le nombre de couleurs bien placees\n" );
  77.     printf("(a l aide de pion noir) et le nombre de couleurs mal placees\n" );
  78.     printf("(a l aide de pion blanc). Si le nombre maximal d essais est atteint,\n" );
  79.     printf("le programme indique au joueur qu il a perdu et donne la combinaison.\n\n" );
  80.     printf("------------------------------------------------------------------------------\n\n" );
  81.     printf("Entrez (0) pour revenir au menu principale\n" );
  82.     scanf("%d", &choix);
  83.    
  84.     if (choix == 0)
  85.     {
  86.         menu();
  87.     }
  88.     else
  89.     {
  90.         regles();
  91.     }   
  92.              
  93. }
  94. // ------------------------------------------------------------------------------------------------------------------------------------------
  95.     void jeu()
  96.     {
  97.         int essais=1,choix=0, ligne=9,continuer=1,verif=0,a; // "entrer" dans la boucle jeu
  98.         char tab[10][8]={
  99.                             {42,42,42,42,46,46,46,46},
  100.                             {42,42,42,42,46,46,46,46},
  101.                             {42,42,42,42,46,46,46,46},
  102.                             {42,42,42,42,46,46,46,46},
  103.                             {42,42,42,42,46,46,46,46},
  104.                             {42,42,42,42,46,46,46,46},
  105.                             {42,42,42,42,46,46,46,46},
  106.                             {42,42,42,42,46,46,46,46},
  107.                             {42,42,42,42,46,46,46,46},
  108.                             {42,42,42,42,46,46,46,46}
  109.                         };
  110.         char comb[4];
  111.                 system("cls" ); // Nettoyer la console
  112.                 // --------------------------------------------------------------------------------------------------------
  113. // Générer une combinaison aléatoire
  114. void initCode(int *codeSecret)
  115. {
  116. int i;
  117. srand (time(NULL));
  118. /* initialiser le code secret avec un choix de 6 couleurs */
  119. for (i = 0; i < 4 ; i++)
  120. {
  121.  switch (rand() % 6)
  122.  {
  123.   case 0: codeSecret[i] = 'r'; break;
  124.   case 1: codeSecret[i] = 'b'; break;
  125.   case 2: codeSecret[i] = 'v'; break;
  126.   case 3: codeSecret[i] = 'j'; break;
  127.   case 4: codeSecret[i] = 'o'; break;
  128.   case 5: codeSecret[i] = 'm'; break;
  129.  }
  130. }
  131. // -----------------------------------------------------------------------------------------------------------------------------------------------------
  132.             // Jeu du MASTERMIND
  133.             while (essais <= 10)
  134.             {
  135.                 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
  136.                 char rep[4]={'\0'};
  137.                 int a,b; // variable pour la vérification des combinaisons entrées
  138.                 system("cls" ); // Nettoyer la console
  139.                 printf("\nCouleurs disponibles : \n" );
  140.                 printf("=========================================================\n" );
  141.                 printf("r=Rouge - v=Vert - b=Bleu - j=Jaune - o=Orange - m=Marron \n" );
  142.                 printf("=========================================================\n\n" );
  143.                 // initialisation du tableau
  144.                 for (i=0;i<=9;i++)
  145.                 {
  146.                     printf ("[%3d]-[",L);
  147.                     for (j=0;j<=7;j++)
  148.                     {
  149.                         printf ("(%c)",tab[i][j]);
  150.                     }
  151.                     printf (" ]\n" );
  152.                     L--;
  153.                 }
  154.                 //printf("\n comb : %s",comb);
  155.             // --------------------------------------------------------------------------------------------------------
  156.                 // Entrer une combinaison
  157.                 while (verif != 4)
  158.                 {
  159.                     verif=0;
  160.                     printf("\n\nEssai n# %d: \n",essais);
  161.                     scanf("%s",&rep);
  162.                     fflush(stdin);
  163.                     // vérification de la combinaison entrée
  164.                     for (a=0;a<=3;a++)
  165.                     {
  166.                         if (rep[a]=='r' || rep[a]=='v' || rep[a]=='b' || rep[a]=='j' || rep[a]=='o' || rep[a]=='m' )
  167.                         {
  168.                             verif++;
  169.                         }
  170.                         else
  171.                         {
  172.                             verif--;
  173.                         }
  174.                     }
  175.                     if (verif !=4)
  176.                     {
  177.                         printf("\nCombinaison impossible. Recommencez !" );
  178.                     }
  179.                 }
  180.             // -----------------------------------------------------------------------------------------------------------
  181.                 // Ajout dans le combinaison dans le tableau
  182.                 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
  183.                 if (test==0)
  184.                 {
  185.                     essais=11; // le joueur a trouvé la combinaison, on quitte la boucle jeu
  186.                 }
  187.                 else
  188.                 {
  189.                     for (j=0;j<=3;j++) // se déplacer de cellule en cellule
  190.                     {
  191.                         for (t=0;t<=3;t++) // permet de se déplacer dans la chaine de caractère comb, afin d'analyser chaque lettre
  192.                         {
  193.                             if (j == t) // si j == t, on est à la même position dans la chaine
  194.                             {
  195.                                 if (rep[j]==comb[t]) // Si le caractère n°x est égale au caractère n°x de la combinaison
  196.                                 {
  197.                                     tab[ligne][j]=rep[j];
  198.                                     tab[ligne][j+4]=78; // on affiche N (ascii 78)
  199.                                 }
  200.                             }
  201.                             else
  202.                             {
  203.                                 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
  204.                                 {
  205.                                     tab[ligne][j]=rep[j];
  206.                                     tab[ligne][j+4]=66; // on affiche B (ascii 66)
  207.                                 }
  208.                                 else // Sinon on affiche un point
  209.                                 {
  210.                                     tab[ligne][j]=rep[j];
  211.                                     tab[ligne][j+4]=46; // on affiche un point (ascii 46)
  212.                                 }
  213.                             }
  214.                         }
  215.                     }
  216.                 }
  217.                 fflush(stdin);
  218.                 essais++;
  219.                 ligne--;
  220.             }
  221.             // ---------------------------------------------------------------------------------------
  222.             // Jeu terminé
  223.             if (essais == 12) // si essais == 12, alors le joueurs a trouvé la combinaison
  224.             {
  225.                 printf("Jeu termine" );
  226.                 printf("\n\n  ****** B R A V O *****\n" );
  227.                 printf("\n **!!! VOUS AVEZ TROUVE LA COMBINAISON !!!**\n" );
  228.                 printf("\n\n*********************************************************\n" );
  229.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  230.                 scanf ("%d",&choix);
  231.             }
  232.             else
  233.             {
  234.                 system("cls" ); // Nettoyer la console
  235.                 printf("Jeu termine" );
  236.                 printf("\n\n*********************************************************\n" );
  237.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  238.                 scanf ("%d",&choix);
  239.             }
  240.             // ---------------------------------------------------------------------------------------
  241.         if (choix == 0)
  242.         {
  243.             menu();
  244.         }
  245.         else
  246.         {
  247.             jeu();
  248.         }
  249.     }

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>
  5. int menu();
  6. void jeu();
  7. void regles();
  8. // ---------------------------------------------------------------------------------------------------------------------------------------------
  9. void initCode(int *codeSecret);
  10. int main ()
  11. {
  12. int continuer = 1, choix = 0;
  13. int i;
  14. int *codeSecret[4]; // Pourquoi codeSecret est-il un tableau de 4 pointeurs ???
  15.  
  16.    
  17.   for(i=0; i<4; i++)
  18.     printf("%c", codeSecret[i]);
  19. 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...
  20. {
  21.     choix = menu();
  22.     switch (choix)
  23.     {
  24.         case 1:
  25.             jeu();
  26.         break;
  27.     // ----------------------------------
  28.         case 2:
  29.             regles();
  30.         break;
  31.     // ----------------------------------
  32.         case 3:
  33.             // Quitter
  34.             continuer = 0;
  35.             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
  36.         break;
  37.     // ----------------------------------
  38.         default:
  39.             printf("Choix errone\n" );
  40.     }
  41.     // ----------------------------------
  42. } // while
  43. return 0;
  44. }
  45. // ------------------------------------------------------------------------------------------------------------------------------------------------
  46. int menu()
  47. {
  48.          int choix = 0;
  49.        
  50.          system("cls" ); // Nettoyer la console
  51.          printf("======== MENU ========\n\n" );
  52.          printf("(1) : Jouer\n" );
  53.          printf("(2) : Regles du jeu\n" );
  54.          printf("(3) : Quitter\n\n" );
  55.          printf("======================\n\n\n" );
  56.          printf("Que voulez vous faire ?\n\n" );
  57.          scanf("%d", &choix);
  58.        
  59.          return choix;
  60. }
  61. // ------------------------------------------------------------------------------------------------------------------------------------------
  62. void regles()
  63. {
  64.     int choix = 0;
  65.     system("cls" ); //Nettoyer la console
  66.    
  67.     //Affichage des règles du Mastermind
  68.     printf("***********************\n" );
  69.     printf("*REGLES DU MASTERMIND:*\n" );
  70.     printf("***********************\n" );
  71.    
  72.     printf("\nLe programme choisit une combinaison de 4 pions de couleurs au hasard\n" );
  73.     printf("parmi 6 couleurs disponibles.\n" );
  74.     printf("Cette combinaison de pions peut contenir plusieurs fois la meme couleur.\n" );
  75.     printf("L utilisateur essaie de la deviner en proposant au maximum dix combinaisons.\n" );
  76.     printf("Pour chaque tentative le programme indique le nombre de couleurs bien placees\n" );
  77.     printf("(a l aide de pion noir) et le nombre de couleurs mal placees\n" );
  78.     printf("(a l aide de pion blanc). Si le nombre maximal d essais est atteint,\n" );
  79.     printf("le programme indique au joueur qu il a perdu et donne la combinaison.\n\n" );
  80.     printf("------------------------------------------------------------------------------\n\n" );
  81.     printf("Entrez (0) pour revenir au menu principale\n" );
  82.     scanf("%d", &choix);
  83.    
  84.     if (choix == 0)
  85.     {
  86.         menu();
  87.     }
  88.     else
  89.     {
  90.         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" ???
  91.     }   
  92.              
  93. }
  94. // ------------------------------------------------------------------------------------------------------------------------------------------
  95.     void jeu()
  96.     {
  97.         int essais=1,choix=0, ligne=9,continuer=1,verif=0,a; // "entrer" dans la boucle jeu
  98.         char tab[10][8]={
  99.                             {42,42,42,42,46,46,46,46},
  100.                             {42,42,42,42,46,46,46,46},
  101.                             {42,42,42,42,46,46,46,46},
  102.                             {42,42,42,42,46,46,46,46},
  103.                             {42,42,42,42,46,46,46,46},
  104.                             {42,42,42,42,46,46,46,46},
  105.                             {42,42,42,42,46,46,46,46},
  106.                             {42,42,42,42,46,46,46,46},
  107.                             {42,42,42,42,46,46,46,46},
  108.                             {42,42,42,42,46,46,46,46}
  109.                         };    //Pourquoi ces valeurs 42 et 46
  110.         char comb[4];
  111.                 system("cls" ); // Nettoyer la console
  112.                 // --------------------------------------------------------------------------------------------------------
  113. // Générer une combinaison aléatoire
  114. // J'ai dû rater un truc. On est bien dans la fonction jeu() non ???
  115. void initCode(int *codeSecret)
  116. {
  117. int i;
  118. 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.
  119. /* initialiser le code secret avec un choix de 6 couleurs */
  120. for (i = 0; i < 4 ; i++)
  121. {
  122.  switch (rand() % 6)
  123.  {
  124.   case 0: codeSecret[i] = 'r'; break;
  125.   case 1: codeSecret[i] = 'b'; break;
  126.   case 2: codeSecret[i] = 'v'; break;
  127.   case 3: codeSecret[i] = 'j'; break;
  128.   case 4: codeSecret[i] = 'o'; break;
  129.   case 5: codeSecret[i] = 'm'; break;
  130.  }
  131. }
  132. // -----------------------------------------------------------------------------------------------------------------------------------------------------
  133.             // Jeu du MASTERMIND
  134.             while (essais <= 10)
  135.             {
  136.                 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
  137.                 char rep[4]={'\0'};    // char rep[4]=""
  138.                 int a,b; // variable pour la vérification des combinaisons entrées
  139.                 system("cls" ); // Nettoyer la console
  140.                 printf("\nCouleurs disponibles : \n" );
  141.                 printf("=========================================================\n" );
  142.                 printf("r=Rouge - v=Vert - b=Bleu - j=Jaune - o=Orange - m=Marron \n" );
  143.                 printf("=========================================================\n\n" );
  144.                 // initialisation du tableau
  145.                 for (i=0;i<=9;i++)
  146.                 {
  147.                     printf ("[%3d]-[",L);
  148.                     for (j=0;j<=7;j++)
  149.                     {
  150.                         printf ("(%c)",tab[i][j]);
  151.                     }
  152.                     printf (" ]\n" );
  153.                     L--;
  154.                 }
  155.                 //printf("\n comb : %s",comb);
  156.             // --------------------------------------------------------------------------------------------------------
  157.                 // Entrer une combinaison
  158.                 while (verif != 4)
  159.                 {
  160.                     verif=0;
  161.                     printf("\n\nEssai n# %d: \n",essais);
  162.                     scanf("%s",&rep);   //rep est déjà un pointeur !!!
  163.                     fflush(stdin);
  164.                     // vérification de la combinaison entrée
  165.                     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"
  166.                     {
  167.                         if (rep[a]=='r' || rep[a]=='v' || rep[a]=='b' || rep[a]=='j' || rep[a]=='o' || rep[a]=='m' )
  168.                         {
  169.                             verif++;
  170.                         }
  171.                         else
  172.                         {
  173.                             verif--;
  174.                         }
  175.                     }
  176.                     if (verif !=4)
  177.                     {
  178.                         printf("\nCombinaison impossible. Recommencez !" );
  179.                     }
  180.                 }
  181.             // -----------------------------------------------------------------------------------------------------------
  182.                 // Ajout dans le combinaison dans le tableau
  183.                 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"...?
  184.                 if (test==0)
  185.                 {
  186.                     essais=11; // le joueur a trouvé la combinaison, on quitte la boucle jeu
  187.                 }
  188.                 else
  189.                 {
  190.                     for (j=0;j<=3;j++) // se déplacer de cellule en cellule
  191.                     {
  192.                         for (t=0;t<=3;t++) // permet de se déplacer dans la chaine de caractère comb, afin d'analyser chaque lettre
  193.                         {
  194.                             if (j == t) // si j == t, on est à la même position dans la chaine
  195.                             {
  196.                                 if (rep[j]==comb[t]) // Si le caractère n°x est égale au caractère n°x de la combinaison
  197.                                 {
  198.                                     tab[ligne][j]=rep[j];
  199.                                     tab[ligne][j+4]=78; // on affiche N (ascii 78)  ????? tab[ligne][j+4]='N' !!!
  200.                                 }
  201.                             }
  202.                             else
  203.                             {
  204.                                 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
  205.                                 {
  206.                                     tab[ligne][j]=rep[j];
  207.                                     tab[ligne][j+4]=66; // on affiche B (ascii 66) oui oui
  208.                                 }
  209.                                 else // Sinon on affiche un point
  210.                                 {
  211.                                     tab[ligne][j]=rep[j];
  212.                                     tab[ligne][j+4]=46; // on affiche un point (ascii 46) oui oui
  213.                                 }
  214.                             }
  215.                         }
  216.                     }
  217.                 }
  218.                 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)
  219.                 essais++;
  220.                 ligne--;
  221.             }
  222.             // ---------------------------------------------------------------------------------------
  223.             // Jeu terminé
  224.             if (essais == 12) // si essais == 12, alors le joueurs a trouvé la combinaison
  225.             {
  226.                 printf("Jeu termine" );
  227.                 printf("\n\n  ****** B R A V O *****\n" );
  228.                 printf("\n **!!! VOUS AVEZ TROUVE LA COMBINAISON !!!**\n" );
  229.                 printf("\n\n*********************************************************\n" );
  230.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  231.                 scanf ("%d",&choix);
  232.             }
  233.             else
  234.             {
  235.                 system("cls" ); // Nettoyer la console
  236.                 printf("Jeu termine" );
  237.                 printf("\n\n*********************************************************\n" );
  238.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  239.                 scanf ("%d",&choix);
  240.             }
  241.             // ---------------------------------------------------------------------------------------
  242.         if (choix == 0)
  243.         {
  244.             menu();
  245.         }
  246.         else
  247.         {
  248.             jeu();  //Oui, quand une solution fonctionne alors autant l'employer de partout !!!
  249.         }
  250.     }



 
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>
  5. #define OK 1
  6. int menu();
  7. void jeu();
  8. void regles();
  9. // ---------------------------------------------------------------------------------------------------------------------------------------------
  10. void initCode(char *codeSecret);
  11. void analyserCombinaison(char *comb, char *rep, char *resultat);
  12. int main ()
  13. {
  14. int continuer = 1, choix = 0;
  15. while (continuer) // Boucle permettant de choisir ce que l'on veut faire dans le programme
  16. {
  17.     choix = menu();
  18.     switch (choix)
  19.     {
  20.         case 1:
  21.             jeu();
  22.         break;
  23.     // ----------------------------------
  24.         case 2:
  25.             regles();
  26.         break;
  27.     // ----------------------------------
  28.         case 3:
  29.             // Quitter
  30.             continuer = 0;
  31.         break;
  32.     // ----------------------------------
  33.         default:
  34.             printf("Choix errone\n" );
  35.     }
  36.     // ----------------------------------
  37. } // while
  38. return 0;
  39. }
  40. // ------------------------------------------------------------------------------------------------------------------------------------------------
  41. int menu()
  42. {
  43.          int choix = 0;
  44.        
  45.          system("cls" ); // Nettoyer la console
  46.          printf("======== MENU ========\n\n" );
  47.          printf("(1) : Jouer\n" );
  48.          printf("(2) : Regles du jeu\n" );
  49.          printf("(3) : Quitter\n\n" );
  50.          printf("======================\n\n\n" );
  51.          printf("Que voulez vous faire ?\n\n" );
  52.          scanf("%d", &choix);
  53.        
  54.          return choix;
  55. }
  56. // ------------------------------------------------------------------------------------------------------------------------------------------
  57. void regles()
  58. {
  59.     int choix = 0;
  60.     system("cls" ); //Nettoyer la console
  61.    
  62.     //Affichage des règles du Mastermind
  63.     printf("***********************\n" );
  64.     printf("*REGLES DU MASTERMIND:*\n" );
  65.     printf("***********************\n" );
  66.    
  67.     printf("\nLe programme choisit une combinaison de 4 pions de couleurs au hasard\n" );
  68.     printf("parmi 6 couleurs disponibles.\n" );
  69.     printf("Cette combinaison de pions peut contenir plusieurs fois la meme couleur.\n" );
  70.     printf("L utilisateur essaie de la deviner en proposant au maximum dix combinaisons.\n" );
  71.     printf("Pour chaque tentative le programme indique le nombre de couleurs bien placees\n" );
  72.     printf("(a l aide de pion noir) et le nombre de couleurs mal placees\n" );
  73.     printf("(a l aide de pion blanc). Si le nombre maximal d essais est atteint,\n" );
  74.     printf("le programme indique au joueur qu il a perdu et donne la combinaison.\n\n" );
  75.     printf("------------------------------------------------------------------------------\n\n" );
  76.     printf("Entrez (0) pour revenir au menu principale\n" );
  77.     scanf("%d", &choix);
  78.    
  79.     if (choix == 0)
  80.     {
  81.         menu();
  82.     }
  83.     else
  84.     {
  85.         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.
  86.     }   
  87.              
  88. }
  89.     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.
  90.     {
  91.     char repMinuscule[4];
  92.     int a;
  93.     for(a=0;a<4;a++)
  94.     {
  95.      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
  96.      }
  97.    
  98.     int controle[4] = {0,0,0,0};//sert à vérifier s'il n'y a pas un N à cette position
  99.     int j=0;
  100.     int i;
  101.          for( i = 0;i<4;i++)//Sert à détecter les pions noirs
  102.          {
  103.              if (repMinuscule[i]==comb[i])
  104.              {
  105.               resultat[j] = 'N';
  106.               j++;
  107.               controle[i] = OK; 
  108.              }         
  109.          } 
  110.        
  111.          for(i = 0;i<4;i++)//Sert à détecter les pions blancs
  112.          {
  113.                  if(controle[i]!=OK)
  114.                  {
  115.                        int k;
  116.                        for(k=0;k<4;k++)
  117.                        {
  118.                                if (repMinuscule[k]==comb[i] && controle[i]!=OK)
  119.                                {
  120.                                 resultat[j]= 'B';
  121.                                 j++;
  122.                                 controle[i] = OK;
  123.                                }
  124.                                      
  125.                        }
  126.                  }
  127.          }
  128.     }
  129. void initCode(char *codeSecret) //Fonction permettant de générer un code de 4 couleurs avec les initiales des 6 couleurs proposées.
  130. {
  131. int i;
  132. srand (time(NULL));
  133. /* initialiser le code secret avec un choix de 6 couleurs */
  134. for (i = 0; i < 4 ; i++)
  135. {
  136.  switch (rand() % 6)
  137.  {
  138.   case 0: codeSecret[i] = 'r'; break;
  139.   case 1: codeSecret[i] = 'b'; break;
  140.   case 2: codeSecret[i] = 'v'; break;
  141.   case 3: codeSecret[i] = 'j'; break;
  142.   case 4: codeSecret[i] = 'o'; break;
  143.   case 5: codeSecret[i] = 'm'; break;
  144.  }
  145. }
  146. // ------------------------------------------------------------------------------------------------------------------------------------------
  147.     void jeu()
  148.     {
  149.         int essais=0,choix=0, ligne=9,continuer=1,verif=0,a; // "entrer" dans la boucle jeu
  150.         char tab[10][8]={
  151.                             {42,42,42,42,46,46,46,46},
  152.                             {42,42,42,42,46,46,46,46},
  153.                             {42,42,42,42,46,46,46,46},
  154.                             {42,42,42,42,46,46,46,46},
  155.                             {42,42,42,42,46,46,46,46},
  156.                             {42,42,42,42,46,46,46,46},
  157.                             {42,42,42,42,46,46,46,46},
  158.                             {42,42,42,42,46,46,46,46},//Sv@r, 42:*  46:.  j'initialise les valeurs de mon tableau avec ces 2 éléments
  159.                             {42,42,42,42,46,46,46,46},
  160.                             {42,42,42,42,46,46,46,46}
  161.                         };
  162.         char comb[5];
  163.         initCode(comb);
  164.                 system("cls" ); // Nettoyer la console
  165. // -----------------------------------------------------------------------------------------------------------------------------------------------------
  166.             // Jeu du MASTERMIND
  167.             char rep[5]={'\0'};
  168.             while (essais <= 10)
  169.             {
  170.                 char resultat[4]={46,46,46,46};
  171.                 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
  172.                
  173.                 int a,b; // variable pour la vérification des combinaisons entrées
  174.                 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" );
  179.                 // affichage du tableau
  180.                 for (i=0;i<=9;i++)
  181.                 {
  182.                     printf ("[%3d]-[",L);
  183.                     for (j=0;j<=7;j++)
  184.                     {
  185.                         printf ("(%c)",tab[i][j]);
  186.                     }
  187.                     printf (" ]\n" );
  188.                     L++;
  189.                 }
  190.                 //printf("\n Les caracteres saisit sont: %c%c%c%c", rep[0],rep[1],rep[2],rep[3]);
  191.                 //printf("\n comb : %c%c%c%c",comb[0],comb[1],comb[2],comb[3]);
  192.             // --------------------------------------------------------------------------------------------------------
  193.                 // Entrer une combinaison
  194.                 while (verif != 4)
  195.                 {
  196.                     verif=0;
  197.                     printf("\n\nEssai n# %d: \n",essais);
  198.                     scanf("%s",&rep);
  199.                     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 .. */
  200.                     // vérification de la combinaison entrée
  201.                     for (a=0;a<=3;a++)
  202.                     {
  203.                         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' )
  204.                         {
  205.                             verif++;
  206.                         }
  207.                         else
  208.                         {
  209.                             verif--;
  210.                         }
  211.                     }
  212.                     if (verif !=4)
  213.                     {
  214.                         printf("\nCombinaison impossible. Recommencez !" );
  215.                     }
  216.                 }
  217.                
  218.                
  219.                 verifierCombi(comb,rep,resultat);
  220.                
  221.                
  222.                 tab[essais][0]=rep[0];
  223.                 tab[essais][1]=rep[1];
  224.                 tab[essais][2]=rep[2];
  225.                 tab[essais][3]=rep[3];
  226.                 tab[essais][4]=resultat[0];
  227.                 tab[essais][5]=resultat[1];
  228.                 tab[essais][6]=resultat[2];
  229.                 tab[essais][7]=resultat[3];
  230.              
  231.               if (resultat[0]=='N' && resultat[1]=='N' && resultat[2]=='N' && resultat[3]=='N')// Si 4 'N' alors le joueur a trouvé le code secret
  232.                 {
  233.                    essais=99;
  234.                                      }
  235.                 else{
  236.                      essais++;
  237.                 }
  238.     }           
  239.                
  240.                
  241.             // ---------------------------------------------------------------------------------------
  242.             // Jeu terminé
  243.             if (essais == 99) // si essais == 99, alors le joueurs a trouvé la combinaison
  244.             {
  245.                 printf("Jeu termine" );
  246.                 printf("\n\n  ****** B R A V O *****\n" );
  247.                 printf("\n **!!! VOUS AVEZ TROUVE LA COMBINAISON !!!**\n" );
  248.                 printf("\n\n*********************************************************\n" );
  249.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  250.                 scanf ("%d",&choix);
  251.             }
  252.             else
  253.             {
  254.                 system("cls" ); // Nettoyer la console
  255.                 printf("Jeu termine" );
  256.                 printf("\n\n*********************************************************\n" );
  257.                 printf("---- Entrez (0) pour revenir au menu principal ou (1) pour rejouer : " );
  258.                 scanf ("%d",&choix);
  259.             }
  260.             // ---------------------------------------------------------------------------------------
  261.         if (choix == 0)
  262.         {
  263.             menu();
  264.         }
  265.         else
  266.         {
  267.             jeu();
  268.         }
  269.  
  270. }
 

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>
  2. int main()
  3. {
  4.     int x, y;
  5.     char chaine[50];
  6.     while(1)
  7.     {
  8.         printf("Entrez deux nombres séparés par un (ou plusieurs) espace\n" );
  9.         fgets(chaine, 50, stdin);
  10.         if (sscanf(chaine, "%d %d", &x, &y) == 2) break;
  11.         printf("Erreur sur l'un des deux nombres\n" );
  12.     }
  13.     printf("Vous avez entré %d et %d\n", x, y);
  14. }


 
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.

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