Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1048 connectés 

  FORUM HardWare.fr
  Programmation
  C

  Besoin d'aide j'ai un problème dans mon jeu Démineur

 



 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Besoin d'aide j'ai un problème dans mon jeu Démineur

n°2152573
Mister_S
Posté le 04-08-2012 à 19:56:29  profilanswer
 

Bonjour à tous,
 
Je dois concevoir le jeu démineur pour l'un de mes cours.  Il fonctionne assez bien pour le moment.  Par contre ma fonction Annuler_Coup me fait royalement !%&* !!.  Bon je vous explique en gros ce que cette fonction doit faire dans mon programme.  Elle permet d’annuler le dernier coup joué tout simplement.  Donc si dans les opérations je choisi le caractère 'A' ou 'a' cette dernière annule mon dernier coup jouer et remet des 'x' dans le ou les case(s) dévoilées précédement par mon dernier coup joué.
 
voici le programme complet afin que vous puissiez le compiler:
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <malloc.h>
  5.  
  6. /*****************************************************************************
  7. * Auteur    : Gerson Chirinos (CHIG06017603)
  8. *              MAthieu Szarek (SZAM11088707)                                        
  9. *              Alex Couet Morin (COUA19038500)
  10. *                                                                            
  11. * Derniere modification : 08 aout 2012                                        
  12. *                                                                                
  13. * Description : Ce programme est le jeu Demineur.
  14. *
  15. ******************************************************************************/
  16.  
  17. #define MIN    1        // Minimum de lignes et colonnes.
  18. #define MAX    15        // Maximum de lignes et colonnes.
  19.  
  20. //*****************************************************************************
  21. // ENTIER_VALIDE                            
  22. //*****************************************************************************
  23. // Cette fonction permet de valider un entier compris dans un intervalle. Si
  24. // l'entier est valide on le retourne.  Dans le cas ou l'entier est valide on
  25. // affiche OK.  Dans le cas contraire on affiche un message d'erreur et on
  26. // demande a nouveau un nouvel entier.
  27. //*****************************************************************************
  28. // Pre-condition : entier >= 1 && entier <= 15
  29. //*****************************************************************************
  30. // Parametre : msg_sol - message de sollicitation.
  31. //               min - entier minimum permis.
  32. //               max - entier maximum permis.
  33. //*****************************************************************************
  34.  
  35. long Entier_Valide (char msg_sol [], long min, long max);
  36.  
  37.  
  38.  
  39.  
  40. char Caractere_Valide (char msg_solicitation_1 [], char msg_solicitation_2 [], char msg_carac_valides [], char msg_erreur []);
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47. //*****************************************************************************
  48. // MINE_VALIDE                            
  49. //*****************************************************************************
  50. // Cette fonction permet de s'assurer d'un minimum et d'un maximum de mines
  51. // dans les cases du jeu.  Si l'entier est valide on le retourne.  Dans le cas
  52. // ou l'entier est valide on affiche un message d'erreur.
  53. //*****************************************************************************
  54. // Pre-condition : Le nombre de mines à insérer dans le jeu (minimum 10% des
  55. //                   cases du jeu et maximum 80% des cases).
  56. //*****************************************************************************
  57. // Parametre : tab_nbr - les mines.
  58. //               nbr_mine_min - le minimum de mines permises.
  59. //               max - le maximum de mines permises.
  60. //*****************************************************************************
  61.  
  62. int Mine_Valide (char tab_nbm, int nbr_mine_min, int nbr_mine_max);
  63.  
  64. //*****************************************************************************
  65. // **ESPACE_Tab2D_1                    
  66. //*****************************************************************************
  67. // Cette fonction permet la creation de mémoires d'un tableau 2D.  Elle
  68. // retourne jeu, le tableau 2D.
  69. //*****************************************************************************
  70. // Pre-condition : nbl > 0
  71. //*****************************************************************************
  72. // Parametre : nbl - nombre de lignes.
  73. //               nbc - nombre de colonnes.
  74. //*****************************************************************************
  75.  
  76. long **Espace_Tab2D_1 (long nbl, long nbc);
  77.  
  78. //*****************************************************************************
  79. // **ESPACE_TAB2D_2                            
  80. //*****************************************************************************
  81. // Cette fonction permet la creation de mémoires d'un tableau 2D.  Elle
  82. // retourne jeu_aff, le tableau 2D.
  83. //*****************************************************************************
  84. // Pre-condition : nbl > 0
  85. //*****************************************************************************
  86. // Parametre : nbc - nombre de colonnes.
  87. //               nbl - nombre de lignes.
  88. //*****************************************************************************
  89.  
  90. char **Espace_Tab2D_2 (long nbl, long nbc);
  91.  
  92. //*****************************************************************************
  93. // LIBERER_Tab2D_1                            
  94. //*****************************************************************************
  95. // Cette fonction permet d'effacer au complet la memoire du tableau 2D jeu.
  96. //*****************************************************************************
  97. // Pre-condition : nbl > 0
  98. //*****************************************************************************
  99. // Parametre : **jeu - Pointeur du tableau jeu.
  100. //               nbl - nombre de ligne.
  101. //*****************************************************************************
  102.  
  103. void Liberer_Tab2D_1 (long **jeu, long nbl);
  104.  
  105. //*****************************************************************************
  106. // LIBERER_Tab2D_2                        
  107. //*****************************************************************************
  108. // Cette fonction permet d'effacer au complet la memoire du tableau 2D jeu_aff.
  109. //*****************************************************************************
  110. // Pre-condition : nbl > 0
  111. //*****************************************************************************
  112. // Parametre : **jeu_aff - Pointeur du tableau jeu affiche.
  113. //               nbl - nombre de ligne.
  114. //*****************************************************************************
  115.  
  116. void Liberer_Tab2D_2 (char **jeu_aff, long nbl);
  117.  
  118. //*****************************************************************************
  119. // CALCULER_COORD_MINE                    
  120. //*****************************************************************************
  121. // La fonction creer des mines (representees par 99) et ses coordonnees [a,b]
  122. // au hasard.
  123. //*****************************************************************************
  124. // Pre-condition : n < nbm
  125. //                   1 mine est representee par 99
  126. //*****************************************************************************
  127. // Parametre : **jeu - Pointeur du tableau jeu.
  128. //               nbm - nombre de mines.
  129. //               nbl - nombre de lignes.
  130. //               nbc - nombre de colonnes.
  131. //*****************************************************************************
  132.  
  133. void Calculer_Coord_Mine (long **jeu, long nbm, long nbl, long nbc);
  134.  
  135. //*****************************************************************************
  136. // AFFICHER_GRILLE_DE_JEU                    
  137. //*****************************************************************************
  138. // La fonction affiche une grille de jeu, pour le jeu Demineur, avec les mines.
  139. //
  140. //*****************************************************************************
  141. // Pre-condition : n < nbc + 1
  142. //                   n < nbc
  143. //                   x < nbl
  144. //                   y < nbc
  145. //                   1 mine est representee par 99
  146. //*****************************************************************************
  147. // Parametre : **jeu - Pointeur du tableau jeu.
  148. //               nbl - nombre de lignes.
  149. //               nbc - nombre de colonnes.
  150. //               nbm - nombre de mines.
  151. //*****************************************************************************
  152.  
  153. void Afficher_Grille_De_Jeu (long **jeu, long nbm, long nbl, long nbc);
  154.  
  155. //*****************************************************************************
  156. // INITIALISER_JEU                    
  157. //*****************************************************************************
  158. // La fonction choisit aleatoirement des cases dans lesquelles des mines seront
  159. // inserees.  Pour chaque case choisie, le chiffre 99 et inscrit pour
  160. // representer la mine.  Lorsque toutes les mines sont placees, elle inscrit
  161. // dans chaque case non initialisee un chiffre qui represente le nombre de
  162. // mines contigues a cette case (minimum 0 et maximum 8).  Affiche a l'ecran
  163. // le tableau avec les mines (99) placees et un chiffre qui represente le
  164. // nombre de mines contigues.
  165. //*****************************************************************************
  166. // Pre-condition : n < nbm
  167. //                   x >= 0 && x <= 8
  168. //                   y >= 0 && y <= 8
  169. //                   1 mine est representee par 99
  170. //*****************************************************************************
  171. // Parametre : **jeu - Pointeur du tableau jeu.
  172. //               nbl - nombre de lignes.
  173. //               nbc - nombre de colonnes.
  174. //               nbm - nombre de mines.
  175. //*****************************************************************************
  176.  
  177. void Initialiser_Jeu (long **jeu, long nbm, long nbl, long nbc);
  178.  
  179. //*****************************************************************************
  180. // INITIALISER_JEU_AFFICHE                    
  181. //*****************************************************************************
  182. // La fonction initialise chaque case du plan de jeu affiche avec le caractère
  183. // ‘x’.
  184. //*****************************************************************************
  185. // Pre-condition : n = 0 && n < nbc+1
  186. //                   x = 0 && x < nbl
  187. //                   y = 0 && y < nbc
  188. //*****************************************************************************
  189. // Parametre : **jeu_aff - Pointeur du tableau jeu affiche.
  190. //               nbl - nombre de lignes.
  191. //               nbc - nombre de colonnes.
  192. //*****************************************************************************
  193.  
  194. void Initialiser_Jeu_Affiche (char **jeu_aff, long nbl, long nbc);
  195.  
  196. //*****************************************************************************
  197. // NOMBRE_ALEATOIRE
  198. //*****************************************************************************
  199. // Cette fonction permet d'obtenir un nombre au hasard.
  200. //
  201. // L'heure du systeme est utilisee afin d'initialiser le generateur. Ensuite,
  202. // le nombre est genere à l'interieur de l'intervalle donné en parametre.
  203. // Enfin, le nombre est retourne.
  204. //*****************************************************************************
  205. // Pre-condition : aucun.
  206. //*****************************************************************************
  207. // Parametres : min - le nombre minimum.
  208. //              max - le nombre maximum.
  209. //*****************************************************************************
  210.  
  211. long Nombre_Aleatoire (long min, long max);
  212.  
  213. //*****************************************************************************
  214. // NBR_DE_MINE
  215. //*****************************************************************************
  216. // Cette fonction permet d'inscrire dans chaque case non initialisee un chiffre
  217. // qui represente le nombre de mines contigues a cette case (minimum 0 et
  218. // maximum 8).  Retourne P, le nombre de mines contigue a chacune des caes.
  219. //*****************************************************************************
  220. // Pre-condition : n = 1 && n < 9
  221. //                   x >= 0 && x <= nbl - 1
  222. //                   y >= 0 && y <= nbc - 1
  223. //                   1 mine est representee par 99
  224. //*****************************************************************************
  225. // Parametres : x - numero de ligne.
  226. //              y - numero de colonne.
  227. //                **jeu - Pointeur du tableau jeu.
  228. //                nbl - nombre de lignes.
  229. //                nbc - nombre de colonnes.
  230. //*****************************************************************************
  231.  
  232. int Nbr_De_Mine (int x, int y, long **jeu, long nbl, int nbc);
  233.  
  234. //*****************************************************************************
  235. // VALIDER_COUP
  236. //*****************************************************************************
  237. // Cette fonction permet d'inscrire de saisir et valider le numero de ligne et
  238. // de colonne de la case a jouer.  Si valide, le numero de ligne et de colonne
  239. // sont retournes.  Dans le cas contraire, ils sont saisis et valides a nouveau.
  240. //*****************************************************************************
  241. // Pre-condition : aucun.                                                              
  242. //*****************************************************************************
  243. // Parametres : **jeu_aff - Pointeur du tableau jeu affiche.
  244. //              nbl - nombre de lignes.
  245. //                nbc - nombre de colonnes.
  246. //                *ligne_jouee -  numero de ligne jouee.
  247. //                *colonne_jouee - numero de colonne jouee.
  248. //*****************************************************************************
  249.  
  250. void Valider_Coup (char **jeu_aff, long nbl, long nbc, long *ligne_jouee, long *colonne_jouee);
  251.  
  252. //*****************************************************************************
  253. // JOUER_COUP
  254. //*****************************************************************************
  255. // Cette fonction permet de verifier si la case choisie contient une mine.  Si
  256. // valide, le caractere 'M' est insere dans le jeu affiche et le nombre de
  257. // coups possibles devient 0.  Dans le cas contraire, le chiffre se trouvant
  258. // dans la case (0 - 8) est insere dans le jeu affiche.
  259. //*****************************************************************************
  260. // Pre-condition : i < 9
  261. //                   x <= nbl - 1
  262. //                   y <= nbc - 1
  263. //*****************************************************************************
  264. // Parametres : **jeu - Pointeur du tableau jeu.
  265. //                **jeu_aff - Pointeur du tableau jeu affiche.
  266. //              nbl - nombre de lignes.
  267. //                nbc - nombre de colonnes.
  268. //                *ligne_jouee -  numero de ligne jouee.
  269. //                *colonne_jouee - numero de colonne jouee.
  270. //*****************************************************************************
  271.  
  272. void Jouer_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee);
  273.  
  274. //*****************************************************************************
  275. // GRILLE_JEU_AFFICHE
  276. //*****************************************************************************
  277. // Cette fonction permet d'afficher la grille du jeu demineur.
  278. //*****************************************************************************
  279. // Pre-condition : n < nbc + 1
  280. //                   n > 0 && n < 10
  281. //                   n < nbc
  282. //                   x < nbl
  283. //                   y < nbc
  284. //*****************************************************************************
  285. // Parametres : **jeu_aff - Pointeur du tableau jeu affiche.
  286. //              nbl - nombre de lignes.
  287. //                nbc - nbc - nombre de colonnes.
  288. //*****************************************************************************
  289.  
  290. void Grille_Afficher_Jeu (char **jeu_aff, long nbl, long nbc);
  291.  
  292. //*****************************************************************************
  293. // AFFICHER_JEU
  294. //*****************************************************************************
  295. // Cette fonction permet d'afficher la grille du jeu demineur.
  296. //*****************************************************************************
  297. // Pre-condition : aucun.
  298. //*****************************************************************************
  299. // Parametres : **jeu_aff - Pointeur du tableau jeu affiche.
  300. //              nbl - nombre de lignes.
  301. //                nbc - nbc - nombre de colonnes.
  302. //*****************************************************************************
  303.  
  304. void Afficher_Jeu (char **jeu_aff, long nbl, long nbc, long nbm);
  305.  
  306. //*****************************************************************************
  307. // NB_COUPS_POSSIBLES
  308. //*****************************************************************************
  309. // Cette fonction permet de compter le nombre de coups qu'ils restent a jouer.
  310. //
  311. // La fonction retourne le nombre de coups restant a jouer.
  312. //*****************************************************************************
  313. // Pre-condition : x < nbl
  314. //                   y < nbc
  315. //*****************************************************************************
  316. // Parametres : **jeu_aff - Pointeur du tableau jeu affiche.
  317. //              nbl - nombre de lignes.
  318. //                nbc - nbc - nombre de colonnes.
  319. //*****************************************************************************
  320.  
  321. long Nb_Coups_Possibles (char **jeu_aff, long nbl, long nbc);
  322.  
  323. //*****************************************************************************
  324. // ETAT_PARTIE
  325. //*****************************************************************************
  326. // Cette fonction permet de determiner l'etat de la partie.
  327. //
  328. // La fonction verifie si la case a jouer contient une mine.  Si valide, elle
  329. // retourne -1.  Dans le cas contraire la fonction verifie si le nombre de
  330. // coups possible est 0.  Si valide, la fonction retourne 0.  La fonction
  331. // affiche l'etat de la partie.
  332. //*****************************************************************************
  333. // Pre-condition : aucun.
  334. //*****************************************************************************
  335. // Parametres : **jeu - Pointeur du tableau jeu.
  336. //                ligne_jouee -  numero de ligne jouee.
  337. //                colonne_jouee - numero de colonne jouee.
  338. //                ncp - nombre de coups possibles.
  339. //*****************************************************************************
  340.  
  341. int Etat_Partie (long **jeu, long ligne_jouee, long colonne_jouee, long ncp);
  342.  
  343.  
  344.  
  345.  
  346. void Jouer_Partie (long **jeu, char **jeu_aff, long nbl, long nbc, long nbm, int *plig, int *pcol, char msg_solicitation_1 [], char msg_solicitation_2 [], char msg_carac_valides [], char msg_erreur []);
  347.  
  348.  
  349.  
  350.  
  351.  
  352.  
  353. void Annuler_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee);
  354.  
  355.  
  356.  
  357.  
  358.  
  359.  
  360. //*****************************************************************************
  361. //  MAIN    
  362. //*****************************************************************************
  363. // Le programme commence par demander les dimensions de la grille que l'on veut
  364. // creer ainsi que le nombre de mines que l'ont veut inserer.  le programme    
  365. // affiche la grille avec les mines choisis aux hasards.  Affiche aussi dans  
  366. // les autres cases le nombres de mines contigues a cette derniere.  Le        
  367. // programme affiche la grille remplit de 'x'.  Ensuite le programme demande de
  368. // de choisir une case.  Le programme demande de choisir une operation et      
  369. // l'execute.  Si l'usager choisi un caractere autre que ceux permis          
  370. // [M, m, ?, D, d, Q], un message d'erreur est affiche et le programme attend  
  371. // jusqu'a ce qu'un bon caractere soit entrer.  Le programme se termine lorsque
  372. // l'utilisateur saisit q ou Q. Ce dernier peut aussi mettre fin a la partie,
  373. // lorsqu'une mine est decouverte ou que l'utilisateur reussi a gagner la
  374. // partie.
  375. //*****************************************************************************
  376. // Pre-condition : nombre de lignes max 10, un nombre de colonnes (max. 15)
  377. //                   nombre minimum de mines (10%) à inserer dans le jeu
  378. //                   et un nombre maximum (80%) des cases du jeu.
  379. //*****************************************************************************
  380. //  Parametre : Aucun.
  381. //*****************************************************************************
  382.  
  383. int main(void)
  384. {
  385.     int lajouer;                // Numero de ligne a jouee.
  386.     int coajouer;                // Numero de colonne a jouee.
  387.     long **JEU;                    // Pointeur du tableau 2D jeu.
  388.     long Nbl;                    // Nombre de lignes.
  389.     long Nbc;                    // Nombre de colonnes.
  390.     long Nbm;                    // Nombre de mines.
  391.     long mine_min;                // Nombre minimal de mines (10% du jeu).
  392.     long mine_max;                // Nombre maximal de mines (80% du jeu).
  393.     char **JEU_AFF;                // Pointeur du tableau 2D jeu affiche.
  394.     int *plig1 = &lajouer;        // Pointeur du numero de ligne.
  395.     int *pcol1 = &coajouer;        // Pointeur du numero de colonne.
  396.     
  397.     char tab_nbl [] = "Entrez le nombre de rangees(15 max):";
  398.     char tab_nbc [] = "Entrez le nombre de colonnes(15 max):";
  399.     char tab_nbm [] = "Entrez le nombre de mines:";
  400.  
  401.     char msg_solicitation_1 [] = "Quelle operation voulez-vous faire :";
  402.     char msg_solicitation_2 [] = "(M = marquer, ? = Indecis, D = Devoiler, Q = Quitter, A = Annuler):";
  403.     char msg_carac_valides [] = "DM?QAdmqa";
  404.     char msg_erreur [] = "Cette operation n'est pas valide";
  405.  
  406.  
  407.     // Valider le nombre de ligne(s).
  408.     Nbl = Entier_Valide (tab_nbl, MIN, MAX);
  409.     
  410.     // Valider le nombre de colonnes(s).
  411.     Nbc = Entier_Valide (tab_nbc, MIN, MAX);
  412.  
  413.     // Valider le nombre minimum de mines dans le jeu.
  414.     mine_min = 0.1 * Nbl * Nbc;
  415.  
  416.     // Valider le nombre maximum de mines dans le jeu.
  417.     mine_max = 0.8 * Nbl * Nbc;
  418.  
  419.     // Valider le nombre de mines.
  420.     Nbm = Mine_Valide (tab_nbm, mine_min, mine_max);
  421.  
  422.     // Creer la grille de jeu.
  423.     JEU = Espace_Tab2D_1 (Nbl, Nbc);
  424.  
  425.     // Creer la grille de jeu affiche.
  426.     JEU_AFF = Espace_Tab2D_2 (Nbl, Nbc);
  427.  
  428.     // Inserer les 'x'.
  429.     Initialiser_Jeu_Affiche (JEU_AFF, Nbl, Nbc);
  430.  
  431.     // Inserer les mines et le nombres de mines contigues.
  432.     Initialiser_Jeu (JEU, Nbm, Nbl, Nbc);
  433.  
  434.     // Afficher le nombre de coups possibles.
  435.     printf("Appuyer sur une touche pour continuer...\n" );
  436.  
  437.     getch();
  438.  
  439.     system ("cls" );    
  440.  
  441.     //  //// /////  /////         /////       RAJOUTER//
  442.     Jouer_Partie (JEU, JEU_AFF, Nbl, Nbc, Nbm, plig1, pcol1, msg_solicitation_1, msg_solicitation_2, msg_carac_valides, msg_erreur);
  443.     
  444.     // Effacer la memoire du tableau jeu et jeu_aff.
  445.     Liberer_Tab2D_1 (JEU, Nbl);
  446.     Liberer_Tab2D_2 (JEU_AFF, Nbl);
  447.  
  448.     system ("pause" );
  449.     return EXIT_SUCCESS;
  450. }
  451.  
  452.  
  453. // Afficher la grille de jeu (jeu_aff).
  454.  
  455. void Grille_Afficher_Jeu (char **jeu_aff, long nbl, long nbc)
  456. {
  457.     int x;        // Numero de ligne.
  458.     int y;        // Numero de colonne.
  459.     int n;        // Compteur de l'indice (position).
  460.  
  461.     // Afficher l'indice dans le tableau.
  462.     for (n = 0; n < nbc+1; n++)
  463.     {
  464.         if (n == 0)
  465.         {
  466.             printf("\t   " );
  467.         }
  468.  
  469.         if (n > 0 && n < 10)
  470.         {
  471.             printf("  %d ", n);
  472.         }
  473.  
  474.         if (n >= 10)
  475.         {
  476.             printf(" %d ", n);
  477.         }
  478.     }
  479.  
  480.     ///////////////////////////////////////////////////////
  481.     // Afficher une partie de la grille afficher jeu.
  482.     printf("\n\t   _" );
  483.  
  484.     for (n = 0; n < nbc; n++)
  485.     {
  486.         printf("____" );
  487.     }
  488.     printf("\n" );
  489.  
  490.     ///////////////////////////////////////////////////////
  491.     // Afficher une partie de la grille afficher jeu.
  492.     for (x = 0; x < nbl; x++)
  493.     {
  494.         //  Afficher l'entier.
  495.         if (x < 9)
  496.         {
  497.             printf("\n\t %d |", x+1);
  498.         }
  499.  
  500.         //  Afficher l'entier.
  501.         if ( x >= 9)
  502.         {
  503.             printf("\n\t%d |", x+1);
  504.         }
  505.  
  506.         // Afficher les caracteres.
  507.         for (y = 0; y < nbc; y++)
  508.         {
  509.             printf(" %c |", jeu_aff [x][y]);
  510.         }
  511.  
  512.         ///////////////////////////////////////////////////
  513.         // Afficher une partie de la grille afficher jeu.
  514.         printf("\n\t   _" );
  515.         
  516.         for(n = 0; n < nbc; n++)
  517.         {
  518.             printf("____" );
  519.         }
  520.         printf("\n" );
  521.         ///////////////////////////////////////////////////
  522.     }
  523. }
  524.  
  525.  
  526. // Creer un tableau 2D d'entiers, selon le nombre de ligne(s) et colonne(s).
  527.  
  528. long **Espace_Tab2D_1 (long nbl,long nbc)
  529. {
  530.     // Creer tableau 2D d'entiers./////////////
  531.     long **jeu = (long**)malloc(nbl * sizeof(long*));
  532.     
  533.     // Tant qu'un chiffre est plus grand que 0.
  534.     while (nbl > 0)
  535.     {    
  536.         nbl--;
  537.  
  538.         // Creer nombre de ligne(s).
  539.         jeu [nbl] = (long*)malloc(nbc * sizeof(long));
  540.     }
  541.     return jeu;
  542. }
  543.  
  544.  
  545. // Creer un tableau 2D de caracteres, selon le nombre de ligne(s) et colonne(s).
  546.  
  547. char **Espace_Tab2D_2 (long nbl, long nbc)
  548. {
  549.     // Creer tableau 2D de caracteres.///////
  550.     char **jeu_aff = (char**)malloc(nbl * sizeof(char*));
  551.     
  552.     // Tant que le nombre de ligne(s) et plus grand que 0.
  553.     while (nbl > 0)
  554.     {
  555.         nbl--;
  556.  
  557.         // Creer le nombre ligne(s).
  558.         jeu_aff [nbl] = (char*)malloc(nbc * sizeof(char));
  559.     }
  560.     return jeu_aff;
  561. }
  562.  
  563.  
  564. // Effacer la memoire du tableau jeu.
  565.  
  566. void Liberer_Tab2D_1 (long **jeu, long nbl)
  567. {
  568.     // Tant que nombre de ligne(s) est plus grand que 0.
  569.     while (nbl > 0)
  570.     {
  571.         nbl--;
  572.  
  573.         // Effacer le contenu de nombre de ligne.
  574.         free(jeu [nbl]);
  575.     }
  576.  
  577.     // Effacer le contenu du tableau jeu.
  578.     free(jeu);
  579. }
  580.  
  581.  
  582. // Effacer la memoire du tableau jeu affiche.
  583.  
  584. void Liberer_Tab2D_2 (char **jeu_aff, long nbl)
  585. {
  586.     // Tant que nombre de ligne(s) est plus grand que 0.
  587.     while (nbl > 0)
  588.     {
  589.         nbl--;
  590.  
  591.         // Effacer le contenu de nombre de ligne.
  592.         free(jeu_aff [nbl]);
  593.     }
  594.  
  595.     // Effacer le contenu du tableau jeu affiche.
  596.     free(jeu_aff);
  597. }
  598.  
  599.  
  600. // Creer les mines et les coordonnees des nouvelles mines.
  601.  
  602. void Calculer_Coord_Mine (long **jeu, long nbm, long nbl, long nbc)
  603. {
  604.     int n = 0;        // Compteur de l'indice (position).
  605.     int a;            // Numero de colonne(s).
  606.     int b;            // Numero de ligne(s).
  607.     int coor;        // Coodonnees des mines.
  608.     int max;        // Le maximum de colonne dans le tableau.
  609.     int min = 0;    // Le minimum.  /**/*/*/*/*/*///
  610.     
  611.  
  612.     // Tant que l'entier n soit plus petit que le nombre de mines.
  613.     while (n < nbm)
  614.     {    
  615.         // Calculer les coordonnees des mines.
  616.         max = nbc - 1;
  617.         coor = Nombre_Aleatoire (min, max);
  618.         b = coor;
  619.  
  620.         max = nbl - 1;
  621.         coor = Nombre_Aleatoire (min, max);
  622.         a = coor;
  623.  
  624.         if (jeu [a][b] != 99)
  625.         {
  626.             jeu [a][b] = 99;
  627.  
  628.             // Afficher les coordonnees des mines.
  629.             printf("\t(%d , %d)\n", a+1, b+1);
  630.         
  631.             n++;
  632.         }        
  633.     }
  634. }
  635.  
  636. // Creer la grille de jeu avec les mines.
  637.  
  638. void Afficher_Grille_De_Jeu (long **jeu, long nbm, long nbl, long nbc)
  639. {
  640.     int n = 0;        // Numero de colonne(s).
  641.     int x;            // Numero de ligne(s).
  642.     int y;            // Numero de colonne(s).
  643.     int nbr_mine;    // Nombre de mines.
  644.  
  645.     // Generer le nombre de colonnes.
  646.     for (n = 0; n < nbc+1; n++)
  647.     {
  648.         if (n == 0)
  649.         {
  650.             printf("\t   " );
  651.         }
  652.         if (n > 0 && n < 10)
  653.         {
  654.             printf("  %d ", n);
  655.         }
  656.         if (n >= 10)
  657.         {
  658.             printf(" %d ", n);
  659.         }
  660.     }
  661.     ///////////////////////////////////////////////////////
  662.     // Afficher une partie de la grille de jeu.
  663.     printf("\n\t   _" );
  664.  
  665.     for (n = 0; n < nbc; n++)
  666.     {
  667.         printf("____" );
  668.     }
  669.     printf("\n" );
  670.  
  671.     ///////////////////////////////////////////////////////
  672.     // Creer l'autre partie de grille de jeu avec les mines.
  673.     for (x = 0; x < nbl; x++)
  674.     {
  675.         if (x < 9)
  676.         {
  677.             printf("\n\t %d |", x+1);
  678.         }
  679.         
  680.         if (x >= 9)
  681.         {
  682.             printf("\n\t%d |", x+1);
  683.         }
  684.         
  685.         for (y = 0; y < nbc; y++)
  686.         {
  687.             
  688.             // Generer le nombre de ligne.
  689.             if(1)
  690.             {
  691.                 // Afficher les mines.
  692.                 if(jeu [x][y] != 99)
  693.                 {
  694.  
  695.                     nbr_mine = Nbr_De_Mine (x, y, jeu, nbl, nbc);
  696.                     jeu [x][y] = nbr_mine;
  697.  
  698.                     printf(" %d |", jeu [x][y]);
  699.                 }
  700.                 else
  701.                 {
  702.                     printf("%d |", jeu [x][y]);
  703.                 }
  704.             }
  705.         }
  706.  
  707.         
  708.         // Afficher le reste de la grille de jeu.
  709.         printf("\n\t   _" );
  710.         
  711.         for (n = 0; n < nbc; n++)
  712.         {
  713.             printf("____" );
  714.         }
  715.         printf("\n" );
  716.     }
  717. }
  718.  
  719. // Inserer les mines et les chiffres (0 - 8) dans le tableau 2D.
  720.  
  721. void Initialiser_Jeu (long **jeu, long nbm, long nbl, long nbc)
  722. {
  723.     // Afficher les coordonnees des mines.
  724.     printf("voici les coordonnees des mines\n\n" );
  725.     
  726.     Calculer_Coord_Mine (jeu, nbm, nbl, nbc);
  727.  
  728.     printf("\n\n\n" );
  729.     
  730.     Afficher_Grille_De_Jeu (jeu, nbm, nbl, nbc);
  731.  
  732.     printf("\n\n\n" );
  733. }
  734.  
  735.  
  736. // Retourner un chiffre au hasard.
  737.  
  738. long Nombre_Aleatoire (long min, long max)
  739. {
  740.     static time_t t;
  741.  
  742.     t += time(NULL);
  743.     srand(t);
  744.  
  745.     return rand() % (max - min + 1) + min;
  746. }
  747.  
  748.  
  749. // Afficher la grille du tableau.
  750.  
  751. void Afficher_Jeu (char **jeu_aff, long nbl, long nbc, long nbm)
  752. {
  753.     Grille_Afficher_Jeu (jeu_aff, nbl, nbc);
  754.  
  755.     // Afficher le nombre de mines.
  756.     printf("\n\n\n" );
  757.     printf("\t\t Nombre de mines a trouver: %d \n", nbm);
  758. }
  759.  
  760.  
  761. // Verifier qu'un entier soit compris entre 1 et 15.
  762.  
  763. long Entier_Valide (char msg_sol [], long min, long max)
  764. {
  765.     char tab_erreur [] = "numero invalide";        // Message d'erreur.
  766.     char tab_ok [] = "OK";                        // Message ok.
  767.     int entier;                                    // Nombre entier.
  768.  
  769.     do
  770.     {
  771.         // Saisir l'entier au clavier.
  772.         printf("\n %s ", msg_sol);
  773.         flushall();
  774.         scanf("%d", &entier);
  775.  
  776.         // Verifier l'entier.
  777.         if (entier >= min && entier <= max )
  778.         {
  779.             printf(" (%s)\n", tab_ok);
  780.         }
  781.         else
  782.         {
  783.             // Afficher message d'erreur.
  784.             printf(" (%s)\n", tab_erreur);
  785.         }
  786.  
  787.     } while (entier < min || entier > max);
  788.     
  789.     return entier;
  790. }
  791.  
  792.  
  793. // Calculer le nombre de mines autour de chaque case dans le jeu.
  794.  
  795. int Nbr_De_Mine (int x, int y, long **jeu, long nbl, long nbc)
  796. {
  797.     int a;            // Compteur de nombre de ligne.
  798.     int b;            // Compteur de nombre de colonne.
  799.     int p = 0;        // Compteur de nombre de mine(s) autour(s).
  800.  
  801.     // Verifier si la cases est une mine.
  802.     if(jeu [x][y] == 99)
  803.     {
  804.         p--;
  805.     }
  806.  
  807.     // Compter le nombre de mine(s) autour(s) d'une case.
  808.     for(a = x-1; a < x+2; a++)
  809.     {
  810.         for(b = y-1; b < y+2; b++)
  811.         {
  812.             if (a >= 0 && a <= nbl-1 && b >= 0 && b <= nbc-1 && jeu [a][b] == 99)
  813.             {
  814.                 p++;
  815.             }
  816.         }
  817.     }
  818.     return p;
  819. }
  820.  
  821.  
  822. // Verifier que l'entier (mines) soit compris entre 10% et 80% du jeu.
  823.  
  824. int Mine_Valide (char tab_nbm [], int nbr_mine_min, int nbr_mine_max)
  825. {
  826.     int entier;        // Nombre entier.
  827.  
  828.     // Saisir l'entier (mines) au clavier.
  829.     printf("\n %s\n", tab_nbm);
  830.  
  831.     do
  832.     {
  833.         flushall();
  834.         scanf("%d", &entier);
  835.  
  836.         // Verifier que l'entier soit compris entre
  837.         if (entier >= nbr_mine_min && entier <= nbr_mine_max)
  838.         {
  839.             return entier;
  840.         }
  841.         else
  842.         {
  843.             // Afficher message d'erreur.
  844.             printf("\n nombre de mines insuffisantes" );
  845.  
  846.             printf("\n %s\n", tab_nbm);
  847.         }
  848.     } while (entier <= nbr_mine_min || entier >= nbr_mine_max);    
  849. }
  850.  
  851.  
  852. // Inserer les mines et le caractere 'x' dans le tableau 2D.
  853.  
  854. void Initialiser_Jeu_Affiche (char **jeu_aff, long nbl, long nbc)
  855. {
  856.     int x;        // Numeros de lignes.
  857.     int y;        // Numeros de colonnes.
  858.  
  859.     // Afficher le caractere 'x' dans la grille de jeu, selon x et y.
  860.     for (x = 0; x < nbl; x++)
  861.     {        
  862.         for (y = 0; y < nbc; y++)
  863.         {
  864.             jeu_aff [x][y] = 'x';
  865.         }
  866.     }
  867. }
  868.  
  869.  
  870. // Verifier si la case choisie et en presence d'une mine et inserer 'M'.
  871.  
  872. void Jouer_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee)
  873. {
  874.  
  875.     int i, j, k;    // Compteur de l'indice (position).
  876.     long x;            // Ligne jouee.
  877.     long y;            // Colonne jouee.
  878.  
  879.     // Valider ligne jouee.
  880.     x = ligne_jouee;
  881.  
  882.     // Valider colonne jouee.
  883.     y = colonne_jouee;
  884.  
  885.     // Inserer 'M' dans les cases qui contienne un mine (99).
  886.     if (jeu [x][y] == 99)
  887.     {
  888.         jeu_aff [x][y] = 'M';
  889.     }
  890.  
  891.     // Inserer '0' dans les cases sans mine (99).
  892.     if (jeu [x][y] != 99)
  893.     {    
  894.         for (j = 0; j < 9; j++)
  895.         {
  896.             if (jeu [x][y] == j)
  897.             {
  898.                 jeu_aff [x][y] = '0' + j;
  899.             }
  900.         }
  901.     }
  902.  
  903.     // Calculer le nombre de mine entourant chaque case (0 - 8).
  904.     if (jeu [x][y] == 0)
  905.     {
  906.         for (j = x-1; j < x+2; j++)
  907.         {
  908.             for (k = y-1; k < y+2; k++)
  909.             {
  910.                 if (j >= 0 && j <= nbl-1 && k >= 0 && k <= nbc-1)
  911.                 {
  912.                     for (i = 0; i < 9; i++)
  913.                     {    
  914.                         if (jeu [j][k] == i)
  915.                         {
  916.                             jeu_aff [j][k] = '0' + i;
  917.                         }
  918.                     }
  919.                 }
  920.             }
  921.         }
  922.     }
  923. }
  924.  
  925.  
  926. //
  927.  
  928. void Annuler_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee)
  929. {
  930.     int j;        //
  931.     int k;        //
  932.     int x;        /////////////////////
  933.     int y;        //
  934.  
  935.     x = ligne_jouee;
  936.     y = colonne_jouee;
  937.  
  938.     if (jeu [x][y] != 0)
  939.     {
  940.         jeu_aff [x][y] = 'x';
  941.     }
  942.  
  943.     if (jeu [x][y] == 0)
  944.     {
  945.         for (j = x-1; j < x+2; j++)
  946.         {
  947.             for (k = y-1; k < y+2; k++)
  948.             {
  949.                 if (j >= 0 && j <= nbl-1 && k >= 0 && k <= nbc-1)
  950.                 {
  951.                     jeu_aff [j][k] = 'x';
  952.                 }
  953.             }
  954.         }
  955.     }
  956. }
  957.  
  958.  
  959. // Calculer le nombre de coups possibles de jouer.
  960.  
  961. long Nb_Coups_Possibles (char **jeu_aff, long nbl, long nbc)
  962. {
  963.     int x;            // Numero de ligne.
  964.     int y;            // Numero de colonne.
  965.     long n = 0;        // Compteur du nombre de 'x' et '?' restant.
  966.     
  967.     // Calculer le nombre de 'x' et '?' restant.
  968.     for (x = 0; x < nbl; x++)
  969.     {
  970.         for (y = 0; y < nbc; y++)
  971.         {
  972.             if (jeu_aff [x][y] == 'x' || jeu_aff [x][y] == '?')
  973.             {
  974.                 n++;
  975.             }
  976.         }
  977.     }
  978.     return n;
  979. }
  980.  
  981.  
  982. // Verifier la presence de mine et retourner -1.
  983. // Verifier si nombre de coups possibles est '0' et retourner 1.
  984. // Dans tout autre cas retourner 0 et continuer la partie.  
  985.  
  986. int Etat_Partie (long **jeu, long ligne_jouee, long colonne_jouee, long ncp)
  987. {
  988.     long x = ligne_jouee;        // Numero de ligne jouee.
  989.     long y = colonne_jouee;        // Numero de colonne jouee.
  990.  
  991.     // Verifier la presence d'une mine.
  992.     if (jeu [x][y] == 99)
  993.     {
  994.         return -1;
  995.     }
  996.  
  997.     // Verifier la presence de nombre de coups possibles.
  998.     if (ncp == 0)
  999.     {
  1000.         return 1;
  1001.     }
  1002.  
  1003.     // Continuer la partie.
  1004.     else
  1005.     {
  1006.         return 0;
  1007.     }
  1008. }
  1009.  
  1010.  
  1011. // Verifier si le caractere entre est le bon "DM?Q".
  1012.  
  1013. char Caractere_Valide (char msg_solicitation_1 [], char msg_solicitation_2 [], char msg_carac_valides [], char msg_erreur [])
  1014. {
  1015.     char oper;                    // Operation.
  1016.     int a;                        // Variable ou a = 0 (Faux) et a = 1 (Vrai).
  1017.  
  1018.     do
  1019.     {
  1020.         a = 0;
  1021.  
  1022.         // Saisir l'operation au clavier.
  1023.         printf(" %s ", msg_solicitation_1);
  1024.         flushall();
  1025.  
  1026.         printf("\n%s", msg_solicitation_2);
  1027.         flushall();
  1028.         scanf("\n%c", &oper);
  1029.  
  1030.         // Verifier l'operation.
  1031.         if (strchr(msg_carac_valides, oper) == NULL)
  1032.         {
  1033.             a = 1;
  1034.  
  1035.             printf("%s\n", msg_erreur);
  1036.             flushall();
  1037.         }
  1038.     } while (a == 1);
  1039.     return oper;
  1040. }
  1041.  
  1042.  
  1043. // Valider le coup jouee dans le jeu.
  1044.  
  1045. void Valider_Coup (char **jeu_aff, long nbl, long nbc, long *ligne_jouee, long *colonne_jouee)
  1046. {
  1047.     char tab_nbl [] = "Entrez le nombre de rangees:";    // Nombre de ligne.
  1048.     char tab_nbc [] = "Entrez le nombre de colonnes:";    // Nombre de colonne.
  1049.     long x;                                                // Numeros de ligne.
  1050.     long y;                                                // Numeros de colonne.
  1051.     long minimum = 0;                                    // Le minimum.
  1052.     long maximum = 0;                                    // Le maximum.
  1053.  
  1054.     do
  1055.     {
  1056.         minimum = MIN;
  1057.         maximum = nbl;
  1058.         
  1059.         // Verifier si x et y sont des entier valide.
  1060.         x = Entier_Valide (tab_nbl, minimum, maximum) - 1;
  1061.  
  1062.         maximum = nbc;
  1063.  
  1064.         y = Entier_Valide (tab_nbc, minimum, maximum) - 1;
  1065.  
  1066.         // Verifier qu'a la position (x, y) il y a un 'x' ou '?'.
  1067.         if (jeu_aff [x][y] == 'x' || jeu_aff [x][y] == '?')
  1068.         {
  1069.             *ligne_jouee = x;
  1070.             *colonne_jouee = y;
  1071.         }
  1072.     } while (jeu_aff [x][y] != 'x' && jeu_aff [x][y] != '?');
  1073. }
  1074.  
  1075.  
  1076. //
  1077. //
  1078. // A COMMENTER!!!!!!!!!!
  1079. //
  1080. //
  1081.  
  1082. void Jouer_Partie (long **jeu, char **jeu_aff, long nbl, long nbc, long nbm, int *plig, int *pcol, char msg_solicitation_1 [], char msg_solicitation_2 [], char msg_carac_valides [], char msg_erreur [])
  1083. {
  1084.     long ncp;                    // Nombre de coups possibles.
  1085.     long boom = 0;                // Explosion.
  1086.     long ETAT_PARTIE;            // L'etat de la partie.
  1087.     long pnt = 0;                // Partie non terminee.
  1088.     long LIGNE_JOUEE;            // Numero de ligne a jouee.
  1089.     long COLONNE_JOUEE;            // Numero de colonne a jouee.
  1090.     int x;                        // Numero d'indice (ligne).
  1091.     int y;                        // Numero d'indice (colonne).
  1092.     char operation;                // Operation a valider.
  1093.  
  1094.     do
  1095.     {
  1096.         printf("\n\n" );
  1097.         system("cls" );
  1098.  
  1099.         Afficher_Jeu (jeu_aff, nbl, nbc, nbm);//printf tableau de x plus nombre de mines
  1100.  
  1101.         ncp = Nb_Coups_Possibles (jeu_aff, nbl, nbc);
  1102.  
  1103.         printf("\n\t ncp: %d \n", ncp);
  1104.  
  1105.         if (ncp > 0)
  1106.         {
  1107.             Valider_Coup (jeu_aff, nbl, nbc, plig, pcol);
  1108.  
  1109.             operation = Caractere_Valide (msg_solicitation_1, msg_solicitation_2, msg_carac_valides, msg_erreur);
  1110.  
  1111.             LIGNE_JOUEE = *plig;
  1112.             COLONNE_JOUEE = *pcol;
  1113.  
  1114.             ETAT_PARTIE =  Etat_Partie (jeu, LIGNE_JOUEE, COLONNE_JOUEE, ncp);
  1115.  
  1116.             if (operation != 'A' && operation != 'a')
  1117.             {
  1118.                 LIGNE_JOUEE = *plig;
  1119.                 COLONNE_JOUEE = *pcol;
  1120.                 ETAT_PARTIE =  Etat_Partie (jeu, LIGNE_JOUEE, COLONNE_JOUEE, ncp);
  1121.             }
  1122.             
  1123.             if (operation == 'D' || operation == 'd')
  1124.                 {
  1125.                     Jouer_Coup (jeu, jeu_aff, nbl, nbc, LIGNE_JOUEE, COLONNE_JOUEE);
  1126.                     
  1127.                     if (ETAT_PARTIE == -1)
  1128.                     {
  1129.                         printf("\n BOOOOOOMMM !!!!!... Vous venez d'exploser \n Appuyer sur une touche pour continuer...\n" );
  1130.                         
  1131.                         boom = 1;
  1132.                         
  1133.                         getch();
  1134.                         system("cls" );
  1135.                         
  1136.                         Afficher_Jeu ( jeu_aff, nbl, nbc, nbm);//printf tableau de x plus nombre de mines
  1137.                         printf("FIN DE JEU \n" );
  1138.                     }
  1139.                 }
  1140.                 else if (operation == 'M' || operation == 'm')
  1141.                 {    
  1142.                     jeu_aff [*plig][*pcol] = '*';
  1143.                 }
  1144.                 else if (operation == '?')
  1145.                 {
  1146.                     jeu_aff [*plig][*pcol] = '?';
  1147.                 }
  1148.                 else if (operation == 'Q' || operation == 'q')
  1149.                 {
  1150.                     for (x = 0; x < nbl; x++)
  1151.                     {
  1152.                         for(y = 0; y < nbc; y++)
  1153.                         {
  1154.                             if (jeu_aff [x][y] == 'x' || jeu_aff [x][y] == '?')
  1155.                             {
  1156.                                 pnt = 1;
  1157.                             }
  1158.                         }
  1159.                     }
  1160.                 }
  1161.                 else if (operation == 'A' || operation == 'a')
  1162.                 {
  1163.                     Annuler_Coup (jeu, jeu_aff, nbl, nbc, LIGNE_JOUEE, COLONNE_JOUEE);    
  1164.                 }
  1165.         }
  1166.  
  1167.         if (pnt == 1)
  1168.         {
  1169.             printf("\n    LA PARTIE N'EST PAS TERMINÉE \n Appuyer sur une touche pour continuer...\n" );
  1170.             
  1171.             getch();
  1172.             system("cls" );
  1173.             
  1174.             Afficher_Jeu (jeu_aff, nbl, nbc, nbm);//printf tableau de x plus nombre de mines
  1175.             
  1176.             printf("FIN DE JEU \n" );
  1177.             break;
  1178.         }
  1179.  
  1180.         if (ncp == 0)
  1181.         {
  1182.             system("cls" );
  1183.  
  1184.             Afficher_Jeu ( jeu_aff, nbl, nbc, nbm);//printf tableau de x plus nombre de mines
  1185.  
  1186.             printf("\n\n\n\n\t ncp:%d \n BRAVO, Vous avez gagne !!!! \n", ncp);
  1187.         }
  1188.     } while (boom < 1 && ncp > 0 );
  1189.  
  1190.     if (ETAT_PARTIE == 1)
  1191.     {
  1192.         printf("LA PARTIE EST FINIE \n" );
  1193.     }
  1194. }


 
 
 
MERCI D'AVANCE À CELUI QUI POURRA ME DÉBUGER PAR RAPPORT À LA FONCTION void Annuler_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee)
 
 
UNE RÉPONSE RAPIDE SERAIT TRÈS APPRÉCIÉE :D


Message édité par gilou le 09-08-2012 à 21:38:37
mood
Publicité
Posté le 04-08-2012 à 19:56:29  profilanswer
 

n°2153042
cookie-NaN​-chaleur
Posté le 09-08-2012 à 21:05:11  profilanswer
 

Salut, ça aiderait si tu ne mettais que la partie de code concernée et entre des balises [cpp][/cpp]


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  Besoin d'aide j'ai un problème dans mon jeu Démineur

 

Sujets relatifs
probléme d'affichage d'une base de donnés (service web)Problème Slider image qui bug
Problème référencement site sur Google (redirection chez gandi)problème d'utilisation de variable shell dans un script
Besoin d'aide pour trouver un erreurpleasa aide :IE ne reconnait pas la css position
Problème de mise en place d'image en bouton submitproblème dans l'ordre de chargement des images sur explorer
problème avec de manager.canvas.draw de matplotlib et gobject.idle_add 
Plus de sujets relatifs à : Besoin d'aide j'ai un problème dans mon jeu Démineur


Copyright © 1997-2018 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR