Ce forum est maintenant fermé, seule cette archive statique reste consultable.
  FORUM Rue-Montgallet.com
  Programmation
  C - C++

  Démineur en C

Bas de page
Auteur Sujet :

Démineur en C

n°19624
midnightwe​b
Profil : Jeune recrue
Posté le 08-06-2009 à 19:25:19  
 

Bonjour,
 
Je dois programmer un démineur en C sans bibliothèque graphique.
Jusque là ça marche mais je bloque sur la fonction de dévoilement des cases vides.
Lorsqu'on choisit une case, s'il y a des mines autour, le programme affiche le nombre de mines
S'il y a une mines le programme affiche perdu
Mais q'il n'y a ni mines ni mines autour, il affiche seulement "0". Ce qui ne fait pas avancer le jeu.
Je voudrais que dans ce cas, le jeu dévoile les cases vides autour, et en frontière, le nb de mines.
 
Merci à ceux qui pourront me donner des mines
(J'ai essayer de boucler mais le programme tourne sans fin)
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. char JEU[10][10];//grille de jeu  
  5. int i,j;//i les lignes, j les colonnes
  6. char MINES[10][10];//la grille avec les mines
  7. int N;//Nombre de mines autour
  8. ////////////////////////////////////////
  9. // FONCTION AFFICHER LA GRILLE DE JEU //
  10. ////////////////////////////////////////
  11. void AfficheJeu()
  12. {
  13.      printf("   | 1  2  3  4  5  6  7  8  9  10\n" );
  14.      printf("___|______________________________\n" );
  15.      for(i=0;i<10;i++)
  16.            {
  17.                       if(i<9)
  18.                       printf(" %d | ",i+1);
  19.                       else
  20.                       printf("%d | ",i+1);
  21.                for(j=0;j<10;j++)
  22.                {               
  23.                                 printf("%c  ",JEU[i][j]);
  24.                }
  25.                printf("\n" );
  26.            }
  27. }
  28. /////////////////////////////////////////////
  29. // FONCTION CALCULER LE NB DE MINES AUTOUR //
  30. /////////////////////////////////////////////
  31. int NbMinesAutour()
  32. {
  33.     N=0;
  34.          if(MINES[i][j]=='M')
  35.          {
  36.                         printf("Vous avez perdu !!!\n\n" );
  37.                        
  38.                         printf("   | 1  2  3  4  5  6  7  8  9  10\n" );
  39.                         printf("___|______________________________\n" );
  40.                         for(i=0;i<10;i++)
  41.                                          {
  42.                                               if(i<9)
  43.                                               printf(" %d | ",i+1);
  44.                                               else
  45.                                               printf("%d | ",i+1);
  46.                                               for(j=0;j<10;j++)               
  47.                                               printf("%c  ",MINES[i][j]);
  48.                                               printf("\n" );
  49.                                          }                     
  50.                        
  51.          }
  52.                         else
  53.                         {
  54.                             if (i==0)
  55.                             {
  56.                                      if (j==0)
  57.                                      {
  58.                                               if(MINES[i][j+1]=='M')
  59.                                               N++;
  60.                                               if(MINES[i+1][j]=='M')
  61.                                               N++;
  62.                                               if(MINES[i+1][j+1]=='M')
  63.                                               N++;                     
  64.                                      }
  65.                                      else
  66.                                      {
  67.                                          if(j==10)
  68.                                          {
  69.                                                   if(MINES[i][j-1]=='M')
  70.                                                   N++;
  71.                                                   if(MINES[i+1][j-1]=='M')
  72.                                                   N++;
  73.                                                   if(MINES[i+1][j]='M')
  74.                                                   N++;
  75.                                          }
  76.                                          else
  77.                                          {
  78.                                            
  79.                                              if(MINES[i][j-1]=='M')
  80.                                              N++;
  81.                                              if(MINES[i][j+1]=='M')
  82.                                              N++;
  83.                                              if(MINES[i+1][j-1]=='M')
  84.                                              N++;
  85.                                              if(MINES[i+1][j]=='M')
  86.                                              N++;
  87.                                              if(MINES[i+1][j+1]=='M')
  88.                                              N++;
  89.                                          }
  90.                                      }
  91.                             }
  92.                             else
  93.                             {
  94.                                 if (i==10)
  95.                                 {
  96.                                      if (j==0)
  97.                                      {
  98.                                               if(MINES[i-1][j]=='M')
  99.                                               N++;
  100.                                               if(MINES[i-1][j+1]=='M')
  101.                                               N++;
  102.                                               if(MINES[i][j+1]=='M')
  103.                                               N++;                     
  104.                                      }
  105.                                      else
  106.                                      {
  107.                                          if(j==10)
  108.                                          {
  109.                                                   if(MINES[i-1][j-1]=='M')
  110.                                                   N++;
  111.                                                   if(MINES[i-1][j]=='M')
  112.                                                   N++;
  113.                                                   if(MINES[i][j-1]=='M')
  114.                                                   N++;
  115.                                          }
  116.                                          else
  117.                                          {
  118.                                              if(MINES[i-1][j-1]=='M')
  119.                                              N++;
  120.                                              if(MINES[i-1][j]=='M')
  121.                                              N++;
  122.                                              if(MINES[i-1][j+1]=='M')
  123.                                              N++;
  124.                                              if(MINES[i][j-1]=='M')
  125.                                              N++;
  126.                                              if(MINES[i][j+1]=='M')
  127.                                              N++;
  128.                                          }
  129.                                      }
  130.                                 }
  131.                                 else
  132.                                 {
  133.                                     if(MINES[i-1][j-1]=='M')
  134.                                     N++;
  135.                                     if(MINES[i-1][j]=='M')
  136.                                     N++;
  137.                                     if(MINES[i-1][j+1]=='M')
  138.                                     N++;
  139.                                     if(MINES[i][j-1]=='M')
  140.                                     N++;
  141.                                     if(MINES[i][j+1]=='M')
  142.                                     N++;
  143.                                     if(MINES[i+1][j-1]=='M')
  144.                                     N++;
  145.                                     if(MINES[i+1][j]=='M')
  146.                                     N++;
  147.                                     if(MINES[i+1][j+1]=='M')
  148.                                     N++;
  149.                                 }                           
  150.                             }   
  151.                             return(N);
  152.                        }
  153.                                              
  154. }
  155. int main()
  156. {
  157.        int NbMines;//le nombre de mines choisi par le joueur
  158.        char NbMinesTxt[2]; // nombre de mines aux alentours       
  159.        int CompteMines;//compteur de mines
  160.        int choix;//le choix effectué par le joueur pour découvrir ou placer un drapeau
  161.        int c;//le compteur de la boucle
  162.        srand(time(NULL));     
  163.      
  164.        //Afficher le début du jeu
  165.        printf(" ________________________________\n" );
  166.        printf("|                                |\n" );
  167.        printf("|        Jeu du demineur         |\n" );
  168.        printf("|________________________________|\n\n" );
  169.      
  170.        //initialisation des deux grilles
  171.        for(i=0;i<10;i++)
  172.        {
  173.            for(j=0;j<10;j++)
  174.            {
  175.                             JEU[i][j]=' ';//' 'implique case cachée
  176.                             MINES[i][j]='0';                           
  177.            }         
  178.        }
  179.      
  180.        //demander à l'utilisateur de choisir un nombre de mines
  181.        do
  182.        {
  183.                   printf("\nCombien de mines voulez-vous ?\n\n" );
  184.                   scanf("%d",&NbMines);
  185.        }
  186.        while(NbMines>=30);
  187.        printf("D'accord, vous avez choisi de jouer avec %d mines\n\n",NbMines);
  188.      
  189.        //////////////////////////////
  190.        // Initialisation des mines //
  191.        //////////////////////////////
  192.        for (CompteMines=0;CompteMines<NbMines;CompteMines++)
  193.        { 
  194.            i=rand()%10;//on choisit la ligne de manière aléatoire
  195.            j=rand()%10;//on choisit la colonne de manière aléatoire
  196.            if(MINES[i][j]=='0')//On vérifie que la case est libre
  197.            {
  198.                                     MINES[i][j]='M';//on place un M pour indiquer qu'il y a une mine
  199.            }
  200.          
  201.            else
  202.            {
  203.                NbMines++;//Sinon, il y a déjà un M et il faut faire un tour de plus
  204.            }
  205.        }
  206.      
  207.        //Pour vérifier on affiche la grille des mines
  208.        printf("Voici la grille des mines :\n" );
  209.        for(i=0;i<10;i++)
  210.        {
  211.            for(j=0;j<10;j++)
  212.            {
  213.                             printf("%c  ",MINES[i][j]);
  214.            }
  215.            printf("\n" );
  216.        }
  217.        ////////////////////////////
  218.        // Démarrage de la partie //
  219.        ////////////////////////////
  220.      
  221.        //On affiche le jeu au joueur
  222.        printf("\n\nVoici votre grille : A vous de jouer !\n\n" );
  223.        printf("   | 1  2  3  4  5  6  7  8  9  10\n" );
  224.        printf("___|______________________________\n" );
  225.        for(i=0;i<10;i++)
  226.        {
  227.            if(i<9)
  228.            printf(" %d | ",i+1);
  229.            else
  230.            printf("%d | ",i+1);           
  231.            for(j=0;j<10;j++)
  232.            {
  233.                             JEU[i][j]='-';//'-'implique case cachée
  234.                             printf("%c  ",JEU[i][j]);
  235.            }
  236.            printf("\n" );
  237.        }
  238.      
  239.        //On demande au joueur de choisir une case
  240.        //la case est définie par sa ligne i et sa colonne j
  241.        for(c=0;c<(100-NbMines);c++)
  242.        {
  243.            printf("\n\nVeuillez entrer la case choisie (numero de ligne [espace] numero de colonne):\t" );
  244.            scanf("%d %d",&i,&j);
  245.            printf("Vous avez choisi la case (%d,%d).\ Que voulez-vous faire ?\n",i,j);
  246.            i=i-1;
  247.            j=j-1;
  248.          
  249.            // Demander au joueur ce qu'il veut faire
  250.            printf("\t1. Decouvrir une case\n" );
  251.            printf("\t2. Placer un drapeau" );
  252.            do
  253.            {
  254.                         printf("\t\tVotre choix : " );
  255.                         scanf("%d",&choix);
  256.            }
  257.            while (choix<0 || choix>2);
  258.          
  259.            // Choix : dévoiler une case ou placer un drapeau
  260.            switch (choix)
  261.            {
  262.                   case 1 : //fonction devoile mines autour
  263.                          NbMinesAutour();
  264.                          if (N!=0)//Il y a des mines autour
  265.           {
  266.                                   printf("%d\n\n",N);
  267.                                  
  268.                    sprintf(NbMinesTxt,"%d",N);
  269.                    JEU[i][j]=NbMinesTxt[0];
  270.                          }
  271.                          else//Il n'y a pas de mines autour
  272.                          {
  273.                                   JEU[i][j]='0';
  274.                                   printf("%c",JEU[i][j]);
  275.                          }                     
  276.            break;
  277.                   case 2 : JEU[i][j]='D';
  278.                        break;
  279.            }
  280.          
  281.            //AFFICHER LA GRILLE
  282.            AfficheJeu();
  283.                  
  284.        }
  285.        printf("\n\n\t\tBravo vous avez gagné !" );
  286.      
  287.        system("pause" );
  288. return 0;
  289. }


---------------
"Le travail, c'est le refuge des gens qui n'ont rien de mieux à faire." Oscar Wilde
mood
Pub
Posté le 08-06-2009 à 19:25:19  
 

n°19625
midnightwe​b
Profil : Jeune recrue
Posté le 08-06-2009 à 22:53:25  
 

Bon, j'ai continué à bosser : nettoyer le code, fractionner le main, ...
Mais ça buggue encore et toujours quand il n'y a aucune mine détectée dans le proche voisinage ...
Je déprime là  

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. char JEU[10][10];//grille de jeu  
  5. int i,j;//i les lignes, j les colonnes
  6. char MINES[10][10];//la grille avec les mines
  7. int N;//Nombre de mines autour
  8. int NbMines;//le nombre de mines choisi par le joueur
  9. int choix;//le choix effectué par le joueur pour découvrir ou placer un drapeau
  10. //////////////////////////////
  11. // FONCTION INITIALISATION ///
  12. //////////////////////////////
  13. void Init()
  14. {
  15.      for(i=0;i<10;i++)
  16.        {
  17.            for(j=0;j<10;j++)
  18.            {
  19.                             JEU[i][j]='-';//' 'implique case cachée
  20.                             MINES[i][j]='0';                           
  21.            }         
  22.        }
  23. }
  24. ///////////////////////////////
  25. // FONCTION PLACER LES MINES //
  26. ///////////////////////////////
  27. void PlaceMines()
  28. {
  29.        int CompteMines;//compteur de mines
  30.        for (CompteMines=0;CompteMines<NbMines;CompteMines++)
  31.        { 
  32.            i=rand()%10;//on choisit la ligne de manière aléatoire
  33.            j=rand()%10;//on choisit la colonne de manière aléatoire
  34.            if(MINES[i][j]=='0')//On vérifie que la case est libre
  35.            {
  36.                                     MINES[i][j]='M';//on place un M pour indiquer qu'il y a une mine
  37.            }
  38.          
  39.            else
  40.            {
  41.                NbMines++;//Sinon, il y a déjà un M et il faut faire un tour de plus
  42.            }
  43.        }
  44. }
  45. ////////////////////////////////////////
  46. // FONCTION AFFICHER LA GRILLE DE JEU //
  47. ////////////////////////////////////////
  48. void AfficheJeu()
  49. {
  50.      printf("\n\n" );
  51.      printf("   | 1  2  3  4  5  6  7  8  9  10\n" );
  52.      printf("___|______________________________\n" );
  53.      for(i=0;i<10;i++)
  54.            {
  55.                       if(i<9)
  56.                       printf(" %d | ",i+1);
  57.                       else
  58.                       printf("%d | ",i+1);
  59.                for(j=0;j<10;j++)
  60.                {               
  61.                                 printf("%c  ",JEU[i][j]);
  62.                }
  63.                printf("\n" );
  64.            }
  65. }
  66. /////////////////////////////////////////////
  67. // FONCTION CALCULER LE NB DE MINES AUTOUR //
  68. /////////////////////////////////////////////
  69. int NbMinesAutour()
  70. {
  71.     N=0;
  72.          if(MINES[i][j]=='M')
  73.          {
  74.                         printf("Vous avez perdu !!!\n\n" );
  75.                        
  76.                         printf("   | 1  2  3  4  5  6  7  8  9  10\n" );
  77.                         printf("___|______________________________\n" );
  78.                         for(i=0;i<10;i++)
  79.                                          {
  80.                                               if(i<9)
  81.                                               printf(" %d | ",i+1);
  82.                                               else
  83.                                               printf("%d | ",i+1);
  84.                                               for(j=0;j<10;j++)               
  85.                                               printf("%c  ",MINES[i][j]);
  86.                                               printf("\n" );
  87.                                          }                     
  88.                        
  89.          }
  90.                         else
  91.                         {
  92.                             if (i==0)
  93.                             {
  94.                                      if (j==0)
  95.                                      {
  96.                                               if(MINES[i][j+1]=='M')
  97.                                               N++;
  98.                                               if(MINES[i+1][j]=='M')
  99.                                               N++;
  100.                                               if(MINES[i+1][j+1]=='M')
  101.                                               N++;                     
  102.                                      }
  103.                                      else
  104.                                      {
  105.                                          if(j==10)
  106.                                          {
  107.                                                   if(MINES[i][j-1]=='M')
  108.                                                   N++;
  109.                                                   if(MINES[i+1][j-1]=='M')
  110.                                                   N++;
  111.                                                   if(MINES[i+1][j]='M')
  112.                                                   N++;
  113.                                          }
  114.                                          else
  115.                                          {
  116.                                            
  117.                                              if(MINES[i][j-1]=='M')
  118.                                              N++;
  119.                                              if(MINES[i][j+1]=='M')
  120.                                              N++;
  121.                                              if(MINES[i+1][j-1]=='M')
  122.                                              N++;
  123.                                              if(MINES[i+1][j]=='M')
  124.                                              N++;
  125.                                              if(MINES[i+1][j+1]=='M')
  126.                                              N++;
  127.                                          }
  128.                                      }
  129.                             }
  130.                             else
  131.                             {
  132.                                 if (i==10)
  133.                                 {
  134.                                      if (j==0)
  135.                                      {
  136.                                               if(MINES[i-1][j]=='M')
  137.                                               N++;
  138.                                               if(MINES[i-1][j+1]=='M')
  139.                                               N++;
  140.                                               if(MINES[i][j+1]=='M')
  141.                                               N++;                     
  142.                                      }
  143.                                      else
  144.                                      {
  145.                                          if(j==10)
  146.                                          {
  147.                                                   if(MINES[i-1][j-1]=='M')
  148.                                                   N++;
  149.                                                   if(MINES[i-1][j]=='M')
  150.                                                   N++;
  151.                                                   if(MINES[i][j-1]=='M')
  152.                                                   N++;
  153.                                          }
  154.                                          else
  155.                                          {
  156.                                              if(MINES[i-1][j-1]=='M')
  157.                                              N++;
  158.                                              if(MINES[i-1][j]=='M')
  159.                                              N++;
  160.                                              if(MINES[i-1][j+1]=='M')
  161.                                              N++;
  162.                                              if(MINES[i][j-1]=='M')
  163.                                              N++;
  164.                                              if(MINES[i][j+1]=='M')
  165.                                              N++;
  166.                                          }
  167.                                      }
  168.                                 }
  169.                                 else
  170.                                 {
  171.                                     if(MINES[i-1][j-1]=='M')
  172.                                     N++;
  173.                                     if(MINES[i-1][j]=='M')
  174.                                     N++;
  175.                                     if(MINES[i-1][j+1]=='M')
  176.                                     N++;
  177.                                     if(MINES[i][j-1]=='M')
  178.                                     N++;
  179.                                     if(MINES[i][j+1]=='M')
  180.                                     N++;
  181.                                     if(MINES[i+1][j-1]=='M')
  182.                                     N++;
  183.                                     if(MINES[i+1][j]=='M')
  184.                                     N++;
  185.                                     if(MINES[i+1][j+1]=='M')
  186.                                     N++;
  187.                                 }                           
  188.                             }   
  189.                             return(N);
  190.                        }
  191.                                              
  192. }
  193. //////////////////////////////////////////////////////////
  194. // FONCTION JOUER dévoiler une case ou placer un drapeau//
  195. //////////////////////////////////////////////////////////
  196. void Jouer()
  197. {
  198.      char NbMinesTxt[2]; // nombre de mines aux alentours  
  199.      switch (choix)
  200.            {
  201.                   case 1 :
  202.                          NbMinesAutour();
  203.                          if (N!=0)//Il y a des mines autour
  204.           {
  205.                                   printf("%d\n\n",N);
  206.                                  
  207.                    sprintf(NbMinesTxt,"%d",N);
  208.                    JEU[i][j]=NbMinesTxt[0];
  209.                          }
  210.                          else//Il n'y a pas de mines autour
  211.                          {
  212.                                   JEU[i][j]='0';
  213.                                   for(i=i-1;i<i+2;i++)
  214.                                   {
  215.                                                       for(j=j-1;j<j+2;j++)
  216.                                                       NbMinesAutour();
  217.                                   }
  218.                          }                     
  219.            break;
  220.                   case 2 : JEU[i][j]='D';
  221.                        break;
  222.            }
  223.      }
  224.    
  225. ///////////////////////////////////////////////////////////////
  226. // FONCTION CHOISIR On demande au joueur de choisir une case //
  227. ///////////////////////////////////////////////////////////////
  228. void Choisir()
  229. {
  230.      printf("\n\nVeuillez entrer la case choisie (numero de ligne [espace] numero de colonne):\t" );
  231.      scanf("%d %d",&i,&j);
  232.      printf("Vous avez choisi la case (%d,%d).\ Que voulez-vous faire ?\n",i,j);
  233.      i=i-1;
  234.      j=j-1;
  235.      printf("\t1. Decouvrir une case\n" );
  236.      printf("\t2. Placer un drapeau" );
  237.      do
  238.      {
  239.                   printf("\t\tVotre choix : " );
  240.                   scanf("%d",&choix);
  241.      }
  242.      while (choix<0 || choix>2);
  243. }
  244. ////////////////////////////////////////////////////////////////////////////////
  245. int main()
  246. {
  247.        int c;//compteur
  248.        srand(time(NULL));     
  249.      
  250.        //Afficher le début du jeu
  251.        printf(" ________________________________\n" );
  252.        printf("|                                |\n" );
  253.        printf("|        Jeu du demineur         |\n" );
  254.        printf("|________________________________|\n\n" );
  255.      
  256.        Init();
  257.        do
  258.        {
  259.                   printf("\nCombien de mines voulez-vous ?\n\n" );
  260.                   scanf("%d",&NbMines);
  261.        }
  262.        while(NbMines>=30);
  263.        printf("D'accord, vous avez choisi de jouer avec %d mines\n\n",NbMines);     
  264.        PlaceMines();
  265.        printf("Voici la grille des mines pour controle:\n" );
  266.        for(i=0;i<10;i++)
  267.        {
  268.            printf("\t\t\t" );
  269.            for(j=0;j<10;j++)
  270.            {
  271.                             printf("%c  ",MINES[i][j]);
  272.            }
  273.            printf("\n" );
  274.        }
  275.      
  276.        printf("\n\nVoici votre grille : A vous de jouer !\n\n" );
  277.        AfficheJeu();
  278.      
  279.        for(c=0;c<(100-NbMines);c++)
  280.        {
  281.            Choisir();
  282.            Jouer();
  283.            AfficheJeu();         
  284.        }
  285.        printf("\n\n\t\tBravo vous avez gagné !" );
  286.      
  287.        system("pause" );
  288.        return 0;
  289. }


---------------
"Le travail, c'est le refuge des gens qui n'ont rien de mieux à faire." Oscar Wilde
n°19629
cmoila
Profil : Membre
Posté le 12-06-2009 à 17:09:28  
 

Ta question est sur algorithme à utiliser ?
 
La fonction qui répond après que le joueur ait choisi une case doit traiter les 3 cas suivants avec en parametre d'entrée la ref à la case jouée :
 
- cas où la case contient une bombe : réponse "perdu".  
 
- cas ou la case ne contient pas de bombe : calcul du nb de bombes dans les 8 cases autour , puis 2 sous-cas en fonction de ce nb :
     * le nb est > 0 alors la réponse est : afficher ce nb.
     
     * le nb est zéro : là il faut rejouer automatiquement les 8 cases autour.  
        Pour faire cela tu dois donc avoir un fonction "récursive" c'est a dire qui s'appelle elle-même en l'occurrence pour toutes les cases autour d'une case à score nul.
 
 
 
je sais pas si j'ai été clair ;-)    

n°19631
midnightwe​b
Profil : Jeune recrue
Posté le 14-06-2009 à 21:27:57  
 

Salut,  
 
C'est très clair et d'ailleurs c'est ce que j'ai eu du mal à faire. ça bugguer tout le temps mais mes appels à l'aide ont porté leurs fruits.
Merci pour tout

  FORUM Rue-Montgallet.com
  Programmation
  C - C++

  Démineur en C

© 2000-2024 Forum.rue-montgallet.com - Tous droits réservés