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

Marsh Posté le 04-08-2012 à 19:56:29
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 :
#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" );
    }
}
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
Message édité par gilou le 09-08-2012 à 21:38:37
Marsh Posté le 04-08-2012 à 19:56:29
Marsh Posté le 09-08-2012 à 21:05:11
Salut, ça aiderait si tu ne mettais que la partie de code concernée et entre des balises [cpp][/cpp]
Sujets relatifs:

Leave a Replay

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