#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)
{
}
if (n > 0 && n < 10)
{
}
if (n >= 10)
{
}
}
///////////////////////////////////////////////////////
// Afficher une partie de la grille afficher jeu.
for (n = 0; n < nbc; n++)
{
}
///////////////////////////////////////////////////////
// Afficher une partie de la grille afficher jeu.
for (x = 0; x < nbl; x++)
{
// Afficher l'entier.
if (x < 9)
{
}
// Afficher l'entier.
if ( x >= 9)
{
}
// Afficher les caracteres.
for (y = 0; y < nbc; y++)
{
printf(" %c |", jeu_aff
[x
][y
]);
}
///////////////////////////////////////////////////
// Afficher une partie de la grille afficher jeu.
for(n = 0; n < nbc; 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)
{
}
if (n > 0 && n < 10)
{
}
if (n >= 10)
{
}
}
///////////////////////////////////////////////////////
// Afficher une partie de la grille de jeu.
for (n = 0; n < nbc; n++)
{
}
///////////////////////////////////////////////////////
// Creer l'autre partie de grille de jeu avec les mines.
for (x = 0; x < nbl; x++)
{
if (x < 9)
{
}
if (x >= 9)
{
}
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;
}
else
{
}
}
}
// Afficher le reste de la grille de jeu.
for (n = 0; n < nbc; 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);
Afficher_Grille_De_Jeu (jeu, nbm, nbl, nbc);
}
// 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("\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.
flushall();
scanf("%d", &entier);
// Verifier l'entier.
if (entier >= min && entier <= max )
{
}
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.
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" );
}
} 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;
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
{
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
}
}
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
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" );
}
}