#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>
 
/*****************************************************************************
* Auteur    : Gerson Chirinos (CHIG06017603)
*              MAthieu Szarek (SZAM11088707)                                        
*              Alex Couet Morin (COUA19038500)
*                                                                            
* Derniere modification : 08 aout 2012                                        
*                                                                                 
* Description : Ce programme est le jeu Demineur. 
*
******************************************************************************/
 
#define MIN    1        // Minimum de lignes et colonnes.
#define MAX    15        // Maximum de lignes et colonnes. 
 
//*****************************************************************************
// ENTIER_VALIDE                            
//*****************************************************************************
// Cette fonction permet de valider un entier compris dans un intervalle. Si
// l'entier est valide on le retourne.  Dans le cas ou l'entier est valide on
// affiche OK.  Dans le cas contraire on affiche un message d'erreur et on 
// demande a nouveau un nouvel entier.
//*****************************************************************************
// Pre-condition : entier >= 1 && entier <= 15
//*****************************************************************************
// Parametre : msg_sol - message de sollicitation.
//               min - entier minimum permis.
//               max - entier maximum permis.
//*****************************************************************************
 
long Entier_Valide (char msg_sol [], long min, long max);
 
 
 
 
char Caractere_Valide (char msg_solicitation_1 [], char msg_solicitation_2 [], char msg_carac_valides [], char msg_erreur []);
 
 
 
 
 
 
//*****************************************************************************
// MINE_VALIDE                            
//*****************************************************************************
// Cette fonction permet de s'assurer d'un minimum et d'un maximum de mines
// dans les cases du jeu.  Si l'entier est valide on le retourne.  Dans le cas
// ou l'entier est valide on affiche un message d'erreur.
//*****************************************************************************
// Pre-condition : Le nombre de mines à insérer dans le jeu (minimum 10% des 
//                   cases du jeu et maximum 80% des cases).
//*****************************************************************************
// Parametre : tab_nbr - les mines.
//               nbr_mine_min - le minimum de mines permises.
//               max - le maximum de mines permises.
//*****************************************************************************
 
int Mine_Valide (char tab_nbm, int nbr_mine_min, int nbr_mine_max);
 
//*****************************************************************************
// **ESPACE_Tab2D_1                    
//*****************************************************************************
// Cette fonction permet la creation de mémoires d'un tableau 2D.  Elle
// retourne jeu, le tableau 2D.
//*****************************************************************************
// Pre-condition : nbl > 0
//*****************************************************************************
// Parametre : nbl - nombre de lignes.
//               nbc - nombre de colonnes.
//*****************************************************************************
 
long **Espace_Tab2D_1 (long nbl, long nbc);
 
//*****************************************************************************
// **ESPACE_TAB2D_2                            
//*****************************************************************************
// Cette fonction permet la creation de mémoires d'un tableau 2D.  Elle
// retourne jeu_aff, le tableau 2D.
//*****************************************************************************
// Pre-condition : nbl > 0
//*****************************************************************************
// Parametre : nbc - nombre de colonnes.
//               nbl - nombre de lignes.
//*****************************************************************************
 
char **Espace_Tab2D_2 (long nbl, long nbc);
 
//*****************************************************************************
// LIBERER_Tab2D_1                            
//*****************************************************************************
// Cette fonction permet d'effacer au complet la memoire du tableau 2D jeu.
//*****************************************************************************
// Pre-condition : nbl > 0
//*****************************************************************************
// Parametre : **jeu - Pointeur du tableau jeu.
//               nbl - nombre de ligne.
//*****************************************************************************
 
void Liberer_Tab2D_1 (long **jeu, long nbl);
 
//*****************************************************************************
// LIBERER_Tab2D_2                        
//*****************************************************************************
// Cette fonction permet d'effacer au complet la memoire du tableau 2D jeu_aff.
//*****************************************************************************
// Pre-condition : nbl > 0
//*****************************************************************************
// Parametre : **jeu_aff - Pointeur du tableau jeu affiche.
//               nbl - nombre de ligne.
//*****************************************************************************
 
void Liberer_Tab2D_2 (char **jeu_aff, long nbl);
 
//*****************************************************************************
// CALCULER_COORD_MINE                    
//*****************************************************************************
// La fonction creer des mines (representees par 99) et ses coordonnees [a,b] 
// au hasard.
//*****************************************************************************
// Pre-condition : n < nbm
//                   1 mine est representee par 99
//*****************************************************************************
// Parametre : **jeu - Pointeur du tableau jeu.
//               nbm - nombre de mines.
//               nbl - nombre de lignes.
//               nbc - nombre de colonnes.
//*****************************************************************************
 
void Calculer_Coord_Mine (long **jeu, long nbm, long nbl, long nbc);
 
//*****************************************************************************
// AFFICHER_GRILLE_DE_JEU                    
//*****************************************************************************
// La fonction affiche une grille de jeu, pour le jeu Demineur, avec les mines.
// 
//*****************************************************************************
// Pre-condition : n < nbc + 1
//                   n < nbc
//                   x < nbl
//                   y < nbc
//                   1 mine est representee par 99
//*****************************************************************************
// Parametre : **jeu - Pointeur du tableau jeu.
//               nbl - nombre de lignes.
//               nbc - nombre de colonnes.
//               nbm - nombre de mines.
//*****************************************************************************
 
void Afficher_Grille_De_Jeu (long **jeu, long nbm, long nbl, long nbc);
 
//*****************************************************************************
// INITIALISER_JEU                    
//*****************************************************************************
// La fonction choisit aleatoirement des cases dans lesquelles des mines seront 
// inserees.  Pour chaque case choisie, le chiffre 99 et inscrit pour 
// representer la mine.  Lorsque toutes les mines sont placees, elle inscrit
// dans chaque case non initialisee un chiffre qui represente le nombre de
// mines contigues a cette case (minimum 0 et maximum 8).  Affiche a l'ecran
// le tableau avec les mines (99) placees et un chiffre qui represente le 
// nombre de mines contigues.
//*****************************************************************************
// Pre-condition : n < nbm
//                   x >= 0 && x <= 8
//                   y >= 0 && y <= 8
//                   1 mine est representee par 99
//*****************************************************************************
// Parametre : **jeu - Pointeur du tableau jeu.
//               nbl - nombre de lignes.
//               nbc - nombre de colonnes.
//               nbm - nombre de mines.
//*****************************************************************************
 
void Initialiser_Jeu (long **jeu, long nbm, long nbl, long nbc);
 
//*****************************************************************************
// INITIALISER_JEU_AFFICHE                    
//*****************************************************************************
// La fonction initialise chaque case du plan de jeu affiche avec le caractère
// ‘x’.
//*****************************************************************************
// Pre-condition : n = 0 && n < nbc+1
//                   x = 0 && x < nbl
//                   y = 0 && y < nbc
//*****************************************************************************
// Parametre : **jeu_aff - Pointeur du tableau jeu affiche.
//               nbl - nombre de lignes.
//               nbc - nombre de colonnes.
//*****************************************************************************
 
void Initialiser_Jeu_Affiche (char **jeu_aff, long nbl, long nbc);
 
//*****************************************************************************
// NOMBRE_ALEATOIRE
//*****************************************************************************
// Cette fonction permet d'obtenir un nombre au hasard.
//
// L'heure du systeme est utilisee afin d'initialiser le generateur. Ensuite, 
// le nombre est genere à l'interieur de l'intervalle donné en parametre. 
// Enfin, le nombre est retourne.
//*****************************************************************************
// Pre-condition : aucun.
//*****************************************************************************
// Parametres : min - le nombre minimum.
//              max - le nombre maximum.
//*****************************************************************************
 
long Nombre_Aleatoire (long min, long max);
 
//*****************************************************************************
// NBR_DE_MINE
//*****************************************************************************
// Cette fonction permet d'inscrire dans chaque case non initialisee un chiffre
// qui represente le nombre de mines contigues a cette case (minimum 0 et 
// maximum 8).  Retourne P, le nombre de mines contigue a chacune des caes.
//*****************************************************************************
// Pre-condition : n = 1 && n < 9
//                   x >= 0 && x <= nbl - 1
//                   y >= 0 && y <= nbc - 1
//                   1 mine est representee par 99
//*****************************************************************************
// Parametres : x - numero de ligne.
//              y - numero de colonne.
//                **jeu - Pointeur du tableau jeu.
//                nbl - nombre de lignes.
//                nbc - nombre de colonnes.
//*****************************************************************************
 
int Nbr_De_Mine (int x, int y, long **jeu, long nbl, int nbc);
 
//*****************************************************************************
// VALIDER_COUP
//*****************************************************************************
// Cette fonction permet d'inscrire de saisir et valider le numero de ligne et
// de colonne de la case a jouer.  Si valide, le numero de ligne et de colonne
// sont retournes.  Dans le cas contraire, ils sont saisis et valides a nouveau.
//*****************************************************************************
// Pre-condition : aucun.                                                               
//*****************************************************************************
// Parametres : **jeu_aff - Pointeur du tableau jeu affiche.
//              nbl - nombre de lignes.
//                nbc - nombre de colonnes.
//                *ligne_jouee -  numero de ligne jouee.
//                *colonne_jouee - numero de colonne jouee.
//*****************************************************************************
 
void Valider_Coup (char **jeu_aff, long nbl, long nbc, long *ligne_jouee, long *colonne_jouee);
 
//*****************************************************************************
// JOUER_COUP
//*****************************************************************************
// Cette fonction permet de verifier si la case choisie contient une mine.  Si
// valide, le caractere 'M' est insere dans le jeu affiche et le nombre de
// coups possibles devient 0.  Dans le cas contraire, le chiffre se trouvant
// dans la case (0 - 8) est insere dans le jeu affiche.
//*****************************************************************************
// Pre-condition : i < 9
//                   x <= nbl - 1
//                   y <= nbc - 1
//*****************************************************************************
// Parametres : **jeu - Pointeur du tableau jeu.
//                **jeu_aff - Pointeur du tableau jeu affiche.
//              nbl - nombre de lignes.
//                nbc - nombre de colonnes.
//                *ligne_jouee -  numero de ligne jouee.
//                *colonne_jouee - numero de colonne jouee.
//*****************************************************************************
 
void Jouer_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee);
 
//*****************************************************************************
// GRILLE_JEU_AFFICHE
//*****************************************************************************
// Cette fonction permet d'afficher la grille du jeu demineur.
//*****************************************************************************
// Pre-condition : n < nbc + 1
//                   n > 0 && n < 10
//                   n < nbc
//                   x < nbl
//                   y < nbc
//*****************************************************************************
// Parametres : **jeu_aff - Pointeur du tableau jeu affiche.
//              nbl - nombre de lignes.
//                nbc - nbc - nombre de colonnes.
//*****************************************************************************
 
void Grille_Afficher_Jeu (char **jeu_aff, long nbl, long nbc);
 
//*****************************************************************************
// AFFICHER_JEU
//*****************************************************************************
// Cette fonction permet d'afficher la grille du jeu demineur.
//*****************************************************************************
// Pre-condition : aucun.
//*****************************************************************************
// Parametres : **jeu_aff - Pointeur du tableau jeu affiche.
//              nbl - nombre de lignes.
//                nbc - nbc - nombre de colonnes.
//*****************************************************************************
 
void Afficher_Jeu (char **jeu_aff, long nbl, long nbc, long nbm);
 
//*****************************************************************************
// NB_COUPS_POSSIBLES
//*****************************************************************************
// Cette fonction permet de compter le nombre de coups qu'ils restent a jouer.
//
// La fonction retourne le nombre de coups restant a jouer.
//*****************************************************************************
// Pre-condition : x < nbl
//                   y < nbc
//*****************************************************************************
// Parametres : **jeu_aff - Pointeur du tableau jeu affiche.
//              nbl - nombre de lignes.
//                nbc - nbc - nombre de colonnes.
//*****************************************************************************
 
long Nb_Coups_Possibles (char **jeu_aff, long nbl, long nbc);
 
//*****************************************************************************
// ETAT_PARTIE
//*****************************************************************************
// Cette fonction permet de determiner l'etat de la partie.
//
// La fonction verifie si la case a jouer contient une mine.  Si valide, elle
// retourne -1.  Dans le cas contraire la fonction verifie si le nombre de
// coups possible est 0.  Si valide, la fonction retourne 0.  La fonction
// affiche l'etat de la partie.
//*****************************************************************************
// Pre-condition : aucun.
//*****************************************************************************
// Parametres : **jeu - Pointeur du tableau jeu.
//                ligne_jouee -  numero de ligne jouee.
//                colonne_jouee - numero de colonne jouee.
//                ncp - nombre de coups possibles.
//*****************************************************************************
 
int Etat_Partie (long **jeu, long ligne_jouee, long colonne_jouee, long ncp);
 
 
 
 
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 []);
 
 
 
 
 
 
void Annuler_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee);
 
 
 
 
 
 
//*****************************************************************************
//  MAIN    
//*****************************************************************************
// Le programme commence par demander les dimensions de la grille que l'on veut
// creer ainsi que le nombre de mines que l'ont veut inserer.  le programme    
// affiche la grille avec les mines choisis aux hasards.  Affiche aussi dans   
// les autres cases le nombres de mines contigues a cette derniere.  Le        
// programme affiche la grille remplit de 'x'.  Ensuite le programme demande de
// de choisir une case.  Le programme demande de choisir une operation et      
// l'execute.  Si l'usager choisi un caractere autre que ceux permis           
// [M, m, ?, D, d, Q], un message d'erreur est affiche et le programme attend  
// jusqu'a ce qu'un bon caractere soit entrer.  Le programme se termine lorsque
// l'utilisateur saisit q ou Q. Ce dernier peut aussi mettre fin a la partie,
// lorsqu'une mine est decouverte ou que l'utilisateur reussi a gagner la
// partie.
//*****************************************************************************
// Pre-condition : nombre de lignes max 10, un nombre de colonnes (max. 15)
//                   nombre minimum de mines (10%) à inserer dans le jeu
//                   et un nombre maximum (80%) des cases du jeu.
//*****************************************************************************
//  Parametre : Aucun.
//*****************************************************************************
 
int main(void)
{
    int lajouer;                // Numero de ligne a jouee.
    int coajouer;                // Numero de colonne a jouee.
    long **JEU;                    // Pointeur du tableau 2D jeu.
    long Nbl;                    // Nombre de lignes.
    long Nbc;                    // Nombre de colonnes.
    long Nbm;                    // Nombre de mines.
    long mine_min;                // Nombre minimal de mines (10% du jeu).
    long mine_max;                // Nombre maximal de mines (80% du jeu).
    char **JEU_AFF;                // Pointeur du tableau 2D jeu affiche.
    int *plig1 = &lajouer;        // Pointeur du numero de ligne.
    int *pcol1 = &coajouer;        // Pointeur du numero de colonne.
    
    char tab_nbl [] = "Entrez le nombre de rangees(15 max):";
    char tab_nbc [] = "Entrez le nombre de colonnes(15 max):";
    char tab_nbm [] = "Entrez le nombre de mines:";
 
    char msg_solicitation_1 [] = "Quelle operation voulez-vous faire :";
    char msg_solicitation_2 [] = "(M = marquer, ? = Indecis, D = Devoiler, Q = Quitter, A = Annuler):";
    char msg_carac_valides [] = "DM?QAdmqa";
    char msg_erreur [] = "Cette operation n'est pas valide";
 
 
    // Valider le nombre de ligne(s).
    Nbl = Entier_Valide (tab_nbl, MIN, MAX);
    
    // Valider le nombre de colonnes(s).
    Nbc = Entier_Valide (tab_nbc, MIN, MAX);
 
    // Valider le nombre minimum de mines dans le jeu.
    mine_min = 0.1 * Nbl * Nbc;
 
    // Valider le nombre maximum de mines dans le jeu.
    mine_max = 0.8 * Nbl * Nbc;
 
    // Valider le nombre de mines.
    Nbm = Mine_Valide (tab_nbm, mine_min, mine_max);
 
    // Creer la grille de jeu.
    JEU = Espace_Tab2D_1 (Nbl, Nbc);
 
    // Creer la grille de jeu affiche.
    JEU_AFF = Espace_Tab2D_2 (Nbl, Nbc);
 
    // Inserer les 'x'.
    Initialiser_Jeu_Affiche (JEU_AFF, Nbl, Nbc);
 
    // Inserer les mines et le nombres de mines contigues.
    Initialiser_Jeu (JEU, Nbm, Nbl, Nbc);
 
    // Afficher le nombre de coups possibles.
    printf("Appuyer sur une touche pour continuer...\n" );
 
    getch();
 
    system ("cls" );    
 
    //  //// /////  /////         /////       RAJOUTER//
    Jouer_Partie (JEU, JEU_AFF, Nbl, Nbc, Nbm, plig1, pcol1, msg_solicitation_1, msg_solicitation_2, msg_carac_valides, msg_erreur);
    
    // Effacer la memoire du tableau jeu et jeu_aff.
    Liberer_Tab2D_1 (JEU, Nbl);
    Liberer_Tab2D_2 (JEU_AFF, Nbl);
 
    system ("pause" );
    return EXIT_SUCCESS;
}
 
 
// Afficher la grille de jeu (jeu_aff). 
 
void Grille_Afficher_Jeu (char **jeu_aff, long nbl, long nbc)
{
    int x;        // Numero de ligne.
    int y;        // Numero de colonne.
    int n;        // Compteur de l'indice (position).
 
    // Afficher l'indice dans le tableau.
    for (n = 0; n < nbc+1; n++)
    {
        if (n == 0)
        {
            printf("\t   " );
        }
 
        if (n > 0 && n < 10)
        {
            printf("  %d ", n);
        }
 
        if (n >= 10)
        {
            printf(" %d ", n);
        }
    }
 
    ///////////////////////////////////////////////////////
    // Afficher une partie de la grille afficher jeu.
    printf("\n\t   _" );
 
    for (n = 0; n < nbc; n++)
    {
        printf("____" );
    }
    printf("\n" );
 
    ///////////////////////////////////////////////////////
    // Afficher une partie de la grille afficher jeu.
    for (x = 0; x < nbl; x++)
    {
        //  Afficher l'entier.
        if (x < 9)
        {
            printf("\n\t %d |", x+1);
        }
 
        //  Afficher l'entier.
        if ( x >= 9)
        {
            printf("\n\t%d |", x+1);
        }
 
        // Afficher les caracteres.
        for (y = 0; y < nbc; y++)
        {
            printf(" %c |", jeu_aff [x][y]);
        }
 
        ///////////////////////////////////////////////////
        // Afficher une partie de la grille afficher jeu.
        printf("\n\t   _" );
        
        for(n = 0; n < nbc; n++)
        {
            printf("____" );
        }
        printf("\n" );
        ///////////////////////////////////////////////////
    }
}
 
 
// Creer un tableau 2D d'entiers, selon le nombre de ligne(s) et colonne(s).
 
long **Espace_Tab2D_1 (long nbl,long nbc)
{
    // Creer tableau 2D d'entiers./////////////
    long **jeu = (long**)malloc(nbl * sizeof(long*));
    
    // Tant qu'un chiffre est plus grand que 0.
    while (nbl > 0)
    {    
        nbl--;
 
        // Creer nombre de ligne(s).
        jeu [nbl] = (long*)malloc(nbc * sizeof(long));
    }
    return jeu;
}
 
 
// Creer un tableau 2D de caracteres, selon le nombre de ligne(s) et colonne(s).
 
char **Espace_Tab2D_2 (long nbl, long nbc)
{
    // Creer tableau 2D de caracteres./////// 
    char **jeu_aff = (char**)malloc(nbl * sizeof(char*));
    
    // Tant que le nombre de ligne(s) et plus grand que 0.
    while (nbl > 0)
    {
        nbl--;
 
        // Creer le nombre ligne(s).
        jeu_aff [nbl] = (char*)malloc(nbc * sizeof(char));
    }
    return jeu_aff;
}
 
 
// Effacer la memoire du tableau jeu.
 
void Liberer_Tab2D_1 (long **jeu, long nbl)
{
    // Tant que nombre de ligne(s) est plus grand que 0. 
    while (nbl > 0)
    {
        nbl--;
 
        // Effacer le contenu de nombre de ligne.
        free(jeu [nbl]);
    }
 
    // Effacer le contenu du tableau jeu.
    free(jeu);
}
 
 
// Effacer la memoire du tableau jeu affiche.
 
void Liberer_Tab2D_2 (char **jeu_aff, long nbl)
{
    // Tant que nombre de ligne(s) est plus grand que 0. 
    while (nbl > 0)
    {
        nbl--;
 
        // Effacer le contenu de nombre de ligne.
        free(jeu_aff [nbl]);
    }
 
    // Effacer le contenu du tableau jeu affiche.
    free(jeu_aff);
}
 
 
// Creer les mines et les coordonnees des nouvelles mines.
 
void Calculer_Coord_Mine (long **jeu, long nbm, long nbl, long nbc)
{
    int n = 0;        // Compteur de l'indice (position).
    int a;            // Numero de colonne(s).
    int b;            // Numero de ligne(s).
    int coor;        // Coodonnees des mines.
    int max;        // Le maximum de colonne dans le tableau.
    int min = 0;    // Le minimum.  /**/*/*/*/*/*///
    
 
    // Tant que l'entier n soit plus petit que le nombre de mines.
    while (n < nbm)
    {    
        // Calculer les coordonnees des mines.
        max = nbc - 1;
        coor = Nombre_Aleatoire (min, max);
        b = coor;
 
        max = nbl - 1;
        coor = Nombre_Aleatoire (min, max);
        a = coor;
 
        if (jeu [a][b] != 99)
        {
            jeu [a][b] = 99;
 
            // Afficher les coordonnees des mines.
            printf("\t(%d , %d)\n", a+1, b+1);
        
            n++;
        }        
    }
}
 
// Creer la grille de jeu avec les mines.
 
void Afficher_Grille_De_Jeu (long **jeu, long nbm, long nbl, long nbc)
{
    int n = 0;        // Numero de colonne(s).
    int x;            // Numero de ligne(s).
    int y;            // Numero de colonne(s).
    int nbr_mine;    // Nombre de mines.
 
    // Generer le nombre de colonnes.
    for (n = 0; n < nbc+1; n++)
    {
        if (n == 0)
        {
            printf("\t   " );
        }
        if (n > 0 && n < 10)
        {
            printf("  %d ", n);
        }
        if (n >= 10)
        {
            printf(" %d ", n);
        }
    }
    ///////////////////////////////////////////////////////
    // Afficher une partie de la grille de jeu.
    printf("\n\t   _" );
 
    for (n = 0; n < nbc; n++)
    {
        printf("____" );
    }
    printf("\n" );
 
    ///////////////////////////////////////////////////////
    // Creer l'autre partie de grille de jeu avec les mines.
    for (x = 0; x < nbl; x++)
    {
        if (x < 9)
        {
            printf("\n\t %d |", x+1);
        }
        
        if (x >= 9)
        {
            printf("\n\t%d |", x+1);
        }
        
        for (y = 0; y < nbc; y++)
        {
            
            // Generer le nombre de ligne. 
            if(1)
            {
                // Afficher les mines.
                if(jeu [x][y] != 99)
                {
 
                    nbr_mine = Nbr_De_Mine (x, y, jeu, nbl, nbc);
                    jeu [x][y] = nbr_mine;
 
                    printf(" %d |", jeu [x][y]);
                }
                else
                {
                    printf("%d |", jeu [x][y]);
                }
            }
        }
 
        
        // Afficher le reste de la grille de jeu. 
        printf("\n\t   _" );
        
        for (n = 0; n < nbc; n++)
        {
            printf("____" );
        }
        printf("\n" );
    }
}
 
// Inserer les mines et les chiffres (0 - 8) dans le tableau 2D.
 
void Initialiser_Jeu (long **jeu, long nbm, long nbl, long nbc)
{
    // Afficher les coordonnees des mines.
    printf("voici les coordonnees des mines\n\n" );
    
    Calculer_Coord_Mine (jeu, nbm, nbl, nbc);
 
    printf("\n\n\n" );
    
    Afficher_Grille_De_Jeu (jeu, nbm, nbl, nbc);
 
    printf("\n\n\n" );
}
 
 
// Retourner un chiffre au hasard.
 
long Nombre_Aleatoire (long min, long max)
{
    static time_t t;
 
    t += time(NULL);
    srand(t);
 
    return rand() % (max - min + 1) + min;
}
 
 
// Afficher la grille du tableau.
 
void Afficher_Jeu (char **jeu_aff, long nbl, long nbc, long nbm)
{
    Grille_Afficher_Jeu (jeu_aff, nbl, nbc);
 
    // Afficher le nombre de mines.
    printf("\n\n\n" );
    printf("\t\t Nombre de mines a trouver: %d \n", nbm);
}
 
 
// Verifier qu'un entier soit compris entre 1 et 15.
 
long Entier_Valide (char msg_sol [], long min, long max)
{
    char tab_erreur [] = "numero invalide";        // Message d'erreur.
    char tab_ok [] = "OK";                        // Message ok.
    int entier;                                    // Nombre entier.
 
    do
    {
        // Saisir l'entier au clavier.
        printf("\n %s ", msg_sol);
        flushall();
        scanf("%d", &entier);
 
        // Verifier l'entier.
        if (entier >= min && entier <= max )
        {
            printf(" (%s)\n", tab_ok);
        }
        else
        {
            // Afficher message d'erreur. 
            printf(" (%s)\n", tab_erreur);
        }
 
    } while (entier < min || entier > max);
    
    return entier;
}
 
 
// Calculer le nombre de mines autour de chaque case dans le jeu.
 
int Nbr_De_Mine (int x, int y, long **jeu, long nbl, long nbc)
{
    int a;            // Compteur de nombre de ligne. 
    int b;            // Compteur de nombre de colonne.
    int p = 0;        // Compteur de nombre de mine(s) autour(s).
 
    // Verifier si la cases est une mine.
    if(jeu [x][y] == 99)
    {
        p--;
    }
 
    // Compter le nombre de mine(s) autour(s) d'une case.
    for(a = x-1; a < x+2; a++)
    {
        for(b = y-1; b < y+2; b++)
        {
            if (a >= 0 && a <= nbl-1 && b >= 0 && b <= nbc-1 && jeu [a][b] == 99)
            {
                p++;
            }
        }
    }
    return p;
}
 
 
// Verifier que l'entier (mines) soit compris entre 10% et 80% du jeu.
 
int Mine_Valide (char tab_nbm [], int nbr_mine_min, int nbr_mine_max)
{
    int entier;        // Nombre entier.
 
    // Saisir l'entier (mines) au clavier. 
    printf("\n %s\n", tab_nbm);
 
    do
    {
        flushall();
        scanf("%d", &entier);
 
        // Verifier que l'entier soit compris entre
        if (entier >= nbr_mine_min && entier <= nbr_mine_max)
        {
            return entier;
        }
        else
        {
            // Afficher message d'erreur.
            printf("\n nombre de mines insuffisantes" );
 
            printf("\n %s\n", tab_nbm);
        }
    } while (entier <= nbr_mine_min || entier >= nbr_mine_max);    
}
 
 
// Inserer les mines et le caractere 'x' dans le tableau 2D.
 
void Initialiser_Jeu_Affiche (char **jeu_aff, long nbl, long nbc)
{
    int x;        // Numeros de lignes. 
    int y;        // Numeros de colonnes. 
 
    // Afficher le caractere 'x' dans la grille de jeu, selon x et y.
    for (x = 0; x < nbl; x++)
    {        
        for (y = 0; y < nbc; y++)
        {
            jeu_aff [x][y] = 'x';
        }
    }
}
 
 
// Verifier si la case choisie et en presence d'une mine et inserer 'M'.
 
void Jouer_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee)
{
 
    int i, j, k;    // Compteur de l'indice (position).
    long x;            // Ligne jouee.
    long y;            // Colonne jouee.
 
    // Valider ligne jouee.
    x = ligne_jouee;
 
    // Valider colonne jouee.
    y = colonne_jouee;
 
    // Inserer 'M' dans les cases qui contienne un mine (99).
    if (jeu [x][y] == 99)
    {
        jeu_aff [x][y] = 'M';
    }
 
    // Inserer '0' dans les cases sans mine (99).
    if (jeu [x][y] != 99)
    {    
        for (j = 0; j < 9; j++)
        {
            if (jeu [x][y] == j)
            {
                jeu_aff [x][y] = '0' + j;
            }
        }
    }
 
    // Calculer le nombre de mine entourant chaque case (0 - 8).
    if (jeu [x][y] == 0)
    {
        for (j = x-1; j < x+2; j++)
        {
            for (k = y-1; k < y+2; k++)
            {
                if (j >= 0 && j <= nbl-1 && k >= 0 && k <= nbc-1)
                {
                    for (i = 0; i < 9; i++)
                    {    
                        if (jeu [j][k] == i)
                        {
                            jeu_aff [j][k] = '0' + i;
                        }
                    }
                }
            }
        }
    }
}
 
 
//
 
void Annuler_Coup (long **jeu, char **jeu_aff, long nbl, long nbc, long ligne_jouee, long colonne_jouee)
{
    int j;        //
    int k;        //
    int x;        /////////////////////
    int y;        //
 
    x = ligne_jouee;
    y = colonne_jouee;
 
    if (jeu [x][y] != 0)
    {
        jeu_aff [x][y] = 'x';
    }
 
    if (jeu [x][y] == 0)
    {
        for (j = x-1; j < x+2; j++)
        {
            for (k = y-1; k < y+2; k++)
            {
                if (j >= 0 && j <= nbl-1 && k >= 0 && k <= nbc-1)
                {
                    jeu_aff [j][k] = 'x';
                }
            }
        }
    }
}
 
 
// Calculer le nombre de coups possibles de jouer.
 
long Nb_Coups_Possibles (char **jeu_aff, long nbl, long nbc)
{
    int x;            // Numero de ligne.
    int y;            // Numero de colonne.
    long n = 0;        // Compteur du nombre de 'x' et '?' restant.
    
    // Calculer le nombre de 'x' et '?' restant.
    for (x = 0; x < nbl; x++)
    {
        for (y = 0; y < nbc; y++)
        {
            if (jeu_aff [x][y] == 'x' || jeu_aff [x][y] == '?')
            {
                n++;
            }
        }
    }
    return n;
}
 
 
// Verifier la presence de mine et retourner -1.
// Verifier si nombre de coups possibles est '0' et retourner 1.
// Dans tout autre cas retourner 0 et continuer la partie.  
 
int Etat_Partie (long **jeu, long ligne_jouee, long colonne_jouee, long ncp)
{
    long x = ligne_jouee;        // Numero de ligne jouee. 
    long y = colonne_jouee;        // Numero de colonne jouee.
 
    // Verifier la presence d'une mine.
    if (jeu [x][y] == 99)
    {
        return -1;
    }
 
    // Verifier la presence de nombre de coups possibles.
    if (ncp == 0)
    {
        return 1;
    }
 
    // Continuer la partie. 
    else
    {
        return 0;
    }
}
 
 
// Verifier si le caractere entre est le bon "DM?Q".
 
char Caractere_Valide (char msg_solicitation_1 [], char msg_solicitation_2 [], char msg_carac_valides [], char msg_erreur [])
{
    char oper;                    // Operation.
    int a;                        // Variable ou a = 0 (Faux) et a = 1 (Vrai).
 
    do
    {
        a = 0;
 
        // Saisir l'operation au clavier.
        printf(" %s ", msg_solicitation_1);
        flushall();
 
        printf("\n%s", msg_solicitation_2);
        flushall();
        scanf("\n%c", &oper);
 
        // Verifier l'operation.
        if (strchr(msg_carac_valides, oper) == NULL)
        {
            a = 1;
 
            printf("%s\n", msg_erreur);
            flushall();
        }
    } while (a == 1);
    return oper;
}
 
 
// Valider le coup jouee dans le jeu.
 
void Valider_Coup (char **jeu_aff, long nbl, long nbc, long *ligne_jouee, long *colonne_jouee)
{
    char tab_nbl [] = "Entrez le nombre de rangees:";    // Nombre de ligne.
    char tab_nbc [] = "Entrez le nombre de colonnes:";    // Nombre de colonne.
    long x;                                                // Numeros de ligne.
    long y;                                                // Numeros de colonne.
    long minimum = 0;                                    // Le minimum.
    long maximum = 0;                                    // Le maximum.
 
    do
    {
        minimum = MIN;
        maximum = nbl;
        
        // Verifier si x et y sont des entier valide.
        x = Entier_Valide (tab_nbl, minimum, maximum) - 1;
 
        maximum = nbc;
 
        y = Entier_Valide (tab_nbc, minimum, maximum) - 1;
 
        // Verifier qu'a la position (x, y) il y a un 'x' ou '?'.
        if (jeu_aff [x][y] == 'x' || jeu_aff [x][y] == '?')
        {
            *ligne_jouee = x;
            *colonne_jouee = y;
        }
    } while (jeu_aff [x][y] != 'x' && jeu_aff [x][y] != '?');
} 
 
 
// 
//
// A COMMENTER!!!!!!!!!!
//
//
 
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 [])
{
    long ncp;                    // Nombre de coups possibles.
    long boom = 0;                // Explosion.
    long ETAT_PARTIE;            // L'etat de la partie.
    long pnt = 0;                // Partie non terminee.
    long LIGNE_JOUEE;            // Numero de ligne a jouee.
    long COLONNE_JOUEE;            // Numero de colonne a jouee.
    int x;                        // Numero d'indice (ligne).
    int y;                        // Numero d'indice (colonne).
    char operation;                // Operation a valider.
 
    do
    {
        printf("\n\n" );
        system("cls" );
 
        Afficher_Jeu (jeu_aff, nbl, nbc, nbm);//printf tableau de x plus nombre de mines
 
        ncp = Nb_Coups_Possibles (jeu_aff, nbl, nbc);
 
        printf("\n\t ncp: %d \n", ncp);
 
        if (ncp > 0)
        {
            Valider_Coup (jeu_aff, nbl, nbc, plig, pcol);
 
            operation = Caractere_Valide (msg_solicitation_1, msg_solicitation_2, msg_carac_valides, msg_erreur);
 
            LIGNE_JOUEE = *plig;
            COLONNE_JOUEE = *pcol;
 
            ETAT_PARTIE =  Etat_Partie (jeu, LIGNE_JOUEE, COLONNE_JOUEE, ncp);
 
            if (operation != 'A' && operation != 'a')
            {
                LIGNE_JOUEE = *plig;
                COLONNE_JOUEE = *pcol;
                ETAT_PARTIE =  Etat_Partie (jeu, LIGNE_JOUEE, COLONNE_JOUEE, ncp);
            }
            
            if (operation == 'D' || operation == 'd')
                {
                    Jouer_Coup (jeu, jeu_aff, nbl, nbc, LIGNE_JOUEE, COLONNE_JOUEE);
                    
                    if (ETAT_PARTIE == -1)
                    {
                        printf("\n BOOOOOOMMM !!!!!... Vous venez d'exploser \n Appuyer sur une touche pour continuer...\n" );
                        
                        boom = 1;
                        
                        getch();
                        system("cls" );
                        
                        Afficher_Jeu ( jeu_aff, nbl, nbc, nbm);//printf tableau de x plus nombre de mines
                        printf("FIN DE JEU \n" );
                    }
                }
                else if (operation == 'M' || operation == 'm')
                {    
                    jeu_aff [*plig][*pcol] = '*';
                }
                else if (operation == '?')
                {
                    jeu_aff [*plig][*pcol] = '?';
                }
                else if (operation == 'Q' || operation == 'q')
                {
                    for (x = 0; x < nbl; x++)
                    {
                        for(y = 0; y < nbc; y++)
                        {
                            if (jeu_aff [x][y] == 'x' || jeu_aff [x][y] == '?')
                            {
                                pnt = 1;
                            }
                        }
                    }
                }
                else if (operation == 'A' || operation == 'a')
                {
                    Annuler_Coup (jeu, jeu_aff, nbl, nbc, LIGNE_JOUEE, COLONNE_JOUEE);    
                }
        }
 
        if (pnt == 1)
        {
            printf("\n    LA PARTIE N'EST PAS TERMINÉE \n Appuyer sur une touche pour continuer...\n" );
            
            getch();
            system("cls" );
            
            Afficher_Jeu (jeu_aff, nbl, nbc, nbm);//printf tableau de x plus nombre de mines
            
            printf("FIN DE JEU \n" );
            break;
        }
 
        if (ncp == 0)
        {
            system("cls" );
 
            Afficher_Jeu ( jeu_aff, nbl, nbc, nbm);//printf tableau de x plus nombre de mines
 
            printf("\n\n\n\n\t ncp:%d \n BRAVO, Vous avez gagne !!!! \n", ncp);
        }
    } while (boom < 1 && ncp > 0 );
 
    if (ETAT_PARTIE == 1)
    {
        printf("LA PARTIE EST FINIE \n" );
    }
}