begin process at 2010 02 09 22:39:39
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Jeux

 > JEUX DU DÉMINEUR POUR DÉBUTANT

JEUX DU DÉMINEUR POUR DÉBUTANT


 Description

Cliquez pour voir la capture en taille normale
C'est le jeux classique du démineur en langage C (avec quelques utilisations du C++ mais fonctionne en C si on retire quelques fonctions). Cette source est idéal pour les débutants qui souhaitent comprendre les appels de fonction, la recursivité, l'utilisation d'un booléen... je n'ai utilisé aucun pointeur, l'algorithme est très simple à comprendre, j'ai mis quelque commentaire dans le main.c qui vous permettra d'exécuter pas à pas les appels de fonction jusqu'au programme principal. Il y a quelque détail que j'ai ajouté et qui ne servent qu'a l'esthétique de l'application comme la couleur, le fullscreen, quitter, le clear... Bon amusement :)

  /|\   Quelques inconvénients:
/ | \   -Ne fonctionne pas sous visual à cause de la couleur, supprimez conio.h
/  .  \   et "textcolor" dans main. Sinon, faites le tourner sous DEV-C++. Il n'y      aura pas de bug.
         -Ne fonctionne pas sous linux à cause du fullscreen, il y a un appel du noyau kernel. Supprimez la fonction dans main.


Source

  • // Projet de création du démineur
  • #include <cstdlib>
  • #include <iostream>
  • #include <stdlib.h>
  • #include <string>
  • #include <time.h>
  • #include <conio.c> //permet d'afficher la couleur
  • #include<windows.h> //permet le fullscreen
  • using namespace std;
  • typedef enum {faux, vrai}; //type booléen pour enumérer vrai ou faux à chaque itération
  • const int m = 10;
  • const int n = 10;
  • /*========================================================================
  • |--|
  • |1 | SAISIR LE NOMBRE DE MINES QUE L'ON SOUHAITE
  • |--|
  • =========================================================================*/
  • int saisir_nb_mines(int m, int n){
  • int nb;
  • do{
  • cout<<"Veuillez saisir le nombre de mines que vous voulez placez"<<endl<<endl;
  • cin>>nb;}
  • while(nb<=0 || nb>m*n);
  • return (nb);
  • }
  • /*========================================================================
  • |--|
  • |2 | INITIALISE TOUTES LES CASES DU TABLEAU BIDIMETIONNEL A 0
  • |--|
  • =========================================================================*/
  • void init_tab_2Dentier_0(int M[m][n], int m, int n){
  • int i,j;
  • for(i=0;i<m;i++){
  • for(j=0;j<n;j++){
  • M[i][j] = 0;
  • }
  • }
  • }
  • /*ALGORITHME DE PROGRESSION PAS A PAS { 3 et 4 } */
  • /*========================================================================
  • |--|
  • |3 | AFFICHER LE TABLEAU AVEC TOUT SES 0
  • |--|
  • =========================================================================*/
  • /*void afficher_tab2Dentier(int M[m][n], int m, int n){
  • int i,j=0;
  • cout<<"0 1 2 3 4 5 6 7 8 9"<<endl<<endl;
  • for(i=0;i<m;i++){
  • for(j=0;j<n;j++){
  • cout<<""<<M[i][j]<<" " ;
  • }
  • cout<<" "<<i;
  • cout<<endl<<endl;
  • }
  • }*/
  • /*========================================================================
  • |--|
  • |4 | PLACE LES MINES DE MANIERE ALEATOIRE
  • |--|
  • =========================================================================*/
  • /*void placer_mines(int M[m][n], int m, int n, int nb_mines){
  • int i,j;
  • srand(time(0));
  • rand();
  • do{
  • i = int(((double)(rand())/RAND_MAX)*m);
  • j = int(((double)(rand())/RAND_MAX)*n);
  • if (M[i][j] != -1) {M[i][j] = -1; nb_mines--;}
  • }while(nb_mines!=0);
  • }
  • */
  • /*========================================================================
  • |--|
  • |5 | PLACE LES MINES DE MANIERE ALEATOIRE + INITIALISE LES 8 CASES AUTOUR DE LA MINE
  • |--|
  • =========================================================================*/
  • void initialiser_champ(int M[m][n], int m, int n, int nb_mines)
  • {
  • int i,j;
  • srand(time(0)); //random
  • rand(); //random
  • do{
  • i = int(((double)(rand())/RAND_MAX)*m); //application random, rand_max définit dans stdlib!
  • j = int(((double)(rand())/RAND_MAX)*n);
  • if (M[i][j] != 9) {M[i][j] = 9; nb_mines--;}
  • }while(nb_mines!=0);
  • for(i=0;i<m;i++)
  • {
  • for(j=0;j<n;j++)
  • {
  • /* 1 */ if(M[i][j]!=9 && M[i+1][j+1]==9 && j<n-1) M[i][j]++; // 1 2 3 //
  • /* 2 */ if(M[i][j]!=9 && M[i+1][j]==9) M[i][j]++; // # # # //
  • /* 3 */ if(M[i][j]!=9 && M[i+1][j-1]==9 && j>0) M[i][j]++; // --- //
  • /* 4 */ if(M[i][j]!=9 && M[i][j+1]==9 && j<n-1) M[i][j]++; // 4 |9| 5 //
  • /* 5 */ if(M[i][j]!=9 && M[i][j-1]==9 && j>0) M[i][j]++; // # |9| # //
  • /* 6 */ if(M[i][j]!=9 && M[i-1][j+1]==9 && j<n-1) M[i][j]++; // --- //
  • /* 7 */ if(M[i][j]!=9 && M[i-1][j]==9) M[i][j]++; // 6 7 8 //
  • /* 8 */ if(M[i][j]!=9 && M[i-1][j-1]==9 && j>0) M[i][j]++; // # # # //
  • }
  • }
  • }
  • /*========================================================================
  • |--|
  • |6 | VARIABLE BOOLEENNE V INIATIALISER A FAUX POUR TOUTES LES CASES DU TABLEAU
  • |--|
  • =========================================================================*/
  • void init_tab2Dbool(bool V[m][n], int m, int n){
  • for(int i=0;i<m;i++){
  • for(int j=0;j<n;j++){
  • V[i][j]=false;
  • }
  • }
  • }
  • /*========================================================================
  • |--|
  • |7 | AFFICHE LE TABLEAU SELON LE CARACTERE BOOLEEN DE V
  • |--|
  • =========================================================================*/
  • void afficher_champ(bool V[m][n], int M[m][n], int m, int n, char vf, char vm){
  • for(int i=0;i<m;i++){cout<<" "<<i;}
  • cout<<endl<<endl<<" ";
  • for(int i=0;i<m;i++){
  • for(int j=0;j<n;j++){
  • if(V[i][j]==true)
  • {
  • if(M[i][j]!=9) cout<<M[i][j]<<" ";
  • if(M[i][j]==9) cout<<vm<<" ";
  • }
  • else cout<<vf<<" ";
  • }
  • cout<<" "<<i;
  • cout<<endl<<endl<<" ";
  • }
  • }
  • /*========================================================================
  • |--|
  • |8 | RETOURNE LE NOMBRE D'ELEMENT VISIBLE
  • |--|
  • =========================================================================*/
  • int nb_el_visible(bool V[m][n], int m, int n){
  • int ele;
  • ele=0;
  • for(int i=0;i<m;i++){
  • for(int j=0;j<n;j++){
  • if(V[i][j]==true){ele=ele+1;}
  • }
  • }
  • return(ele);
  • }
  • /*========================================================================
  • |--|
  • |9 | REND VISIBLE TOUTES LES MINES
  • |--|
  • =========================================================================*/
  • void decouverte_mines(bool V[m][n], int M[m][n], int m, int n){
  • for(int i=0;i<m;i++){
  • for(int j=0;j<n;j++){
  • if(M[i][j]==9)
  • {V[i][j]=true;}
  • }
  • }
  • }
  • /*========================================================================
  • |---|
  • |10 | AFFICHE TOUTES LES CASES AYANT 0 ET + PAR RECURSIVITE
  • |---|
  • =========================================================================*/
  • void decouvrir_carre(bool V[m][n], int M[m][n], int m, int n, int i, int j){
  • if(V[i][j]==false)
  • {
  • V[i][j]=true;
  • if(M[i][j]==0)
  • {
  • if(i>0) {decouvrir_carre(V, M, m, n, i-1, j); }
  • if(i>0 && j>0) {decouvrir_carre(V, M, m, n, i-1, j-1);}
  • if(j>0) {decouvrir_carre(V, M, m, n, i, j-1);}
  • if(j>0 && i<m-1) {decouvrir_carre(V, M, m, n, i+1, j-1);}
  • if(i<m-1) {decouvrir_carre(V, M, m, n, i+1, j);}
  • if(i>m-1 && j<n-1) {decouvrir_carre(V, M, m, n, i+1, j+1);}
  • if(j<n-1) {decouvrir_carre(V, M, m, n, i, j+1);}
  • if(i>0 && j<n-1) {decouvrir_carre(V, M, m, n, i-1, j+1);}
  • }
  • }
  • }
  • /*========================================================================
  • |-------|
  • |11 bis | BONUS
  • |-------|
  • =========================================================================*/
  • // PERMET d'afficher des infos à chaque affichage du tableau
  • void CLS(int nb, int ele, int coup){
  • system("CLS");
  • cout<<"__________________________________________________"<<endl;
  • cout<<"Nombres de Mines en jeu : "<<nb<<endl<<endl;
  • cout<<"Cases visibles : "<<ele<<endl<<endl;
  • cout<<"Nombre de coup joue : "<<coup<<endl;
  • cout<<"__________________________________________________"<<endl<<endl<<endl;
  • }
  • // une procédure pour quittez quand le jeu est terminer
  • void quitter(char menu){
  • cout<<"Voulez-vous recommencer\? O/N ";
  • do{cin>>menu; if(menu!='O' && menu!='o' && menu!='N' && menu!='n') cout<<"Mauvais caractere"<<endl;}while(menu!='O' && menu!='o' && menu!='N' && menu!='n');
  • if(menu=='O' || menu=='o') {system("CLS");}
  • if(menu=='N' || menu=='n') {exit(0);}
  • }
  • /*========================================================================
  • |---|
  • |11 | PROGRAMME PRINCIPAL
  • |---|
  • =========================================================================*/
  • int main(int argc)
  • { //permet de lancer l'application en fullscreen, grâce a l'appel de windows.h
  • typedef BOOL (WINAPI *PFONCTION) (HANDLE,DWORD,PCOORD);
  • HMODULE hDLL=LoadLibrary("kernel32.dll");
  • PFONCTION SetDisplayMode = (PFONCTION) GetProcAddress(hDLL,"SetConsoleDisplayMode");
  • HANDLE hconsole = GetStdHandle(STD_OUTPUT_HANDLE);
  • COORD coord;
  • SetDisplayMode (hconsole,1,&coord);
  • //fin fullscreen
  • int champ[m][n],nb,ele,l,c,coup;
  • int couleur1,couleur2;
  • bool visible[m][n];
  • char vf,vm,menu;
  • vf='-';
  • vm='*';
  • menu=' ';
  • textcolor(30); //affiche la console sur la couleur 30 -ecriture en jaune, fond en bleu
  • system("CLS"); //actualise la console, sinon la couleur reste sur "n" caractère imprimé
  • do{
  • ele=0;
  • coup=0;
  • nb= saisir_nb_mines(m, n);
  • system("CLS");
  • init_tab_2Dentier_0(champ, m, n);
  • //placer_mines(champ, m, n, nb);
  • initialiser_champ(champ, m, n, nb);
  • init_tab2Dbool(visible,m,n);
  • do{
  • CLS(nb,ele,coup); //affiche les infos en haut du tableau
  • afficher_champ(visible, champ, m, n, vf, vm);
  • do{cout<<endl<<"Entrez la ligne du carre a rendre visible : "; cin>>l;}while(l<0 && l>m);
  • do{cout<<endl<<"Entrez la colonne du carre a rendre visible : "; cin>>c;}while(c<0 && c>n);
  • coup++;
  • if(champ[l][c]!=9)
  • {
  • decouvrir_carre(visible, champ, m, n, l, c);
  • ele=nb_el_visible(visible, m, n);
  • CLS(nb,ele,coup); //permettra d'afficher les infos en sorti de boucle, cad sur l'état gagnant
  • }
  • }while((nb+ele<n*m) && (champ[l][c]!=9));
  • if
  • (champ[l][c]==9)
  • {
  • CLS(nb,ele,coup);
  • decouverte_mines(visible, champ, m, n);
  • afficher_champ(visible, champ, m, n, vf, vm);
  • cout<<endl<<endl<<endl<<endl<<"----- ----- ----- ----- | | "<<endl;
  • cout<<"| | | | | | \\ | | "<<endl;
  • cout<<"|---- |---- |---- | | | | "<<endl;
  • cout<<"| | | \\ | / | | "<<endl;
  • cout<<"| ----- | \\ ----- ------ \a"<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl;
  • quitter(menu); //continuer ou quitter
  • }
  • else
  • {
  • decouverte_mines(visible, champ, m, n);
  • afficher_champ(visible, champ, m, n, vf, vm);
  • cout<<endl<<endl<<endl<<endl<<"------- /\\ ------- |\\ | ------ * * "<<endl;
  • cout<<"| / \\ | | \\ | | * * "<<endl;
  • cout<<"| |---| /----\\ | |---| | \\ | |----- * * "<<endl;
  • cout<<"| | / \\ | | | \\ | | "<<endl;
  • cout<<"------- / \\ ------- | \\| ------ # # \a \a"<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl;
  • quitter(menu);
  • }
  • }while(m>0);
  • //afficher_tab2Dentier(champ, m, n);
  • return 0;
  • }
// Projet de création du démineur
#include <cstdlib>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <conio.c> //permet d'afficher la couleur
#include<windows.h> //permet le fullscreen

using namespace std;

typedef enum {faux, vrai}; //type booléen pour enumérer vrai ou faux à chaque itération
const int m = 10;
const int n = 10;

/*========================================================================
  |--|   
  |1 |  SAISIR LE NOMBRE DE MINES QUE L'ON SOUHAITE
  |--|
=========================================================================*/
int saisir_nb_mines(int m, int n){
	int nb;
	
	do{
	cout<<"Veuillez saisir le nombre de mines que vous voulez placez"<<endl<<endl;
	cin>>nb;}
	while(nb<=0 || nb>m*n);

	return (nb);
}
/*========================================================================
  |--|   
  |2 |  INITIALISE TOUTES LES CASES DU TABLEAU BIDIMETIONNEL A 0
  |--|
=========================================================================*/
void init_tab_2Dentier_0(int M[m][n], int m, int n){
	int i,j;

	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			M[i][j] = 0;
		}
	}
}
/*ALGORITHME DE PROGRESSION PAS A PAS { 3 et 4 } */
/*========================================================================
  |--|   
  |3 |  AFFICHER LE TABLEAU AVEC TOUT SES 0
  |--|
=========================================================================*/
/*void afficher_tab2Dentier(int M[m][n], int m, int n){
	int i,j=0;
	
	cout<<"0 1 2 3 4 5 6 7 8 9"<<endl<<endl;
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			cout<<""<<M[i][j]<<" " ;
		}
		cout<<"  "<<i;
		cout<<endl<<endl;
	}
}*/
/*========================================================================
  |--|   
  |4 |  PLACE LES MINES DE MANIERE ALEATOIRE
  |--|
=========================================================================*/
/*void placer_mines(int M[m][n], int m, int n, int nb_mines){
               
	int i,j;
	srand(time(0));
	rand();
               
	do{
		i = int(((double)(rand())/RAND_MAX)*m);
		j = int(((double)(rand())/RAND_MAX)*n);
		if (M[i][j] != -1) {M[i][j] = -1; nb_mines--;}
	}while(nb_mines!=0);

}
*/
/*========================================================================
  |--|   
  |5 |  PLACE LES MINES DE MANIERE ALEATOIRE + INITIALISE LES 8 CASES AUTOUR DE LA MINE
  |--|
=========================================================================*/
void initialiser_champ(int M[m][n], int m, int n, int nb_mines)
{
	
	int i,j;
	srand(time(0)); //random
	rand();         //random
         
	do{
		i = int(((double)(rand())/RAND_MAX)*m);  //application random, rand_max définit dans stdlib!
		j = int(((double)(rand())/RAND_MAX)*n);
		if (M[i][j] != 9) {M[i][j] = 9; nb_mines--;}
	}while(nb_mines!=0);
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
		{
/* 1 */		if(M[i][j]!=9 && M[i+1][j+1]==9 && j<n-1) M[i][j]++;	//	1	2	3  //
/* 2 */		if(M[i][j]!=9 && M[i+1][j]==9) M[i][j]++;				//  #	#	#  //
/* 3 */		if(M[i][j]!=9 && M[i+1][j-1]==9 && j>0) M[i][j]++;		//	   ---	   //
/* 4 */		if(M[i][j]!=9 && M[i][j+1]==9 && j<n-1) M[i][j]++;		//  4  |9|	5  //
/* 5 */		if(M[i][j]!=9 && M[i][j-1]==9 && j>0) M[i][j]++;		//	#  |9|	#  //
/* 6 */		if(M[i][j]!=9 && M[i-1][j+1]==9 && j<n-1) M[i][j]++;	//	   ---	   //
/* 7 */		if(M[i][j]!=9 && M[i-1][j]==9) M[i][j]++;				//	6	7	8  //
/* 8 */		if(M[i][j]!=9 && M[i-1][j-1]==9 && j>0) M[i][j]++;		//	#	#	#  //
		}
	}
}
/*========================================================================
  |--|   
  |6 |  VARIABLE BOOLEENNE V INIATIALISER A FAUX POUR TOUTES LES CASES DU TABLEAU
  |--|
=========================================================================*/
void init_tab2Dbool(bool V[m][n], int m, int n){
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			V[i][j]=false;
		}
	}
}
/*========================================================================
  |--|   
  |7 |  AFFICHE LE TABLEAU SELON LE CARACTERE BOOLEEN DE V
  |--|
=========================================================================*/
void afficher_champ(bool V[m][n], int M[m][n], int m, int n, char vf, char vm){
	for(int i=0;i<m;i++){cout<<" "<<i;}
	cout<<endl<<endl<<" ";

	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){		
			if(V[i][j]==true)
			{
				if(M[i][j]!=9) cout<<M[i][j]<<" ";
				if(M[i][j]==9)  cout<<vm<<" ";
			}
		else cout<<vf<<" ";
		}
		cout<<"  "<<i;
		cout<<endl<<endl<<" ";
	}
}
/*========================================================================
  |--|   
  |8 |  RETOURNE LE NOMBRE D'ELEMENT VISIBLE
  |--|
=========================================================================*/
int nb_el_visible(bool V[m][n], int m, int n){
	int ele;
	ele=0;
	
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			if(V[i][j]==true){ele=ele+1;}
		}
	}
	return(ele);
}
/*========================================================================
  |--|   
  |9 |  REND VISIBLE TOUTES LES MINES
  |--|
=========================================================================*/
void decouverte_mines(bool V[m][n], int M[m][n], int m, int n){
	
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			if(M[i][j]==9) 
			{V[i][j]=true;}
		}
	}
}
/*========================================================================
  |---|   
  |10 |  AFFICHE TOUTES LES CASES AYANT 0 ET + PAR RECURSIVITE
  |---|
=========================================================================*/
void decouvrir_carre(bool V[m][n], int M[m][n], int m, int n, int i, int j){
	if(V[i][j]==false)
	{		
		V[i][j]=true;
		if(M[i][j]==0)
		{
			if(i>0) {decouvrir_carre(V, M, m, n, i-1, j); }
			if(i>0 && j>0) {decouvrir_carre(V, M, m, n, i-1, j-1);}
			if(j>0) {decouvrir_carre(V, M, m, n, i, j-1);}
			if(j>0 && i<m-1) {decouvrir_carre(V, M, m, n, i+1, j-1);}
			if(i<m-1) {decouvrir_carre(V, M, m, n, i+1, j);}
			if(i>m-1 && j<n-1) {decouvrir_carre(V, M, m, n, i+1, j+1);}
			if(j<n-1) {decouvrir_carre(V, M, m, n, i, j+1);}
			if(i>0 && j<n-1) {decouvrir_carre(V, M, m, n, i-1, j+1);}
		}
	}
}
/*========================================================================
  |-------|   
  |11 bis |  BONUS
  |-------|
=========================================================================*/
// PERMET d'afficher des infos à chaque affichage du tableau
void CLS(int nb, int ele, int coup){
		system("CLS");
		cout<<"__________________________________________________"<<endl;
		cout<<"Nombres de Mines en jeu : "<<nb<<endl<<endl;
		cout<<"Cases visibles : "<<ele<<endl<<endl;
		cout<<"Nombre de coup joue : "<<coup<<endl;
		cout<<"__________________________________________________"<<endl<<endl<<endl;
}
// une procédure pour quittez quand le jeu est terminer
void quitter(char menu){
		cout<<"Voulez-vous recommencer\? O/N "; 
		do{cin>>menu; if(menu!='O' && menu!='o' && menu!='N' && menu!='n') cout<<"Mauvais caractere"<<endl;}while(menu!='O' && menu!='o' && menu!='N' && menu!='n');
		if(menu=='O' || menu=='o') {system("CLS");}
		if(menu=='N' || menu=='n') {exit(0);}
}
/*========================================================================
  |---|   
  |11 |  PROGRAMME PRINCIPAL
  |---|
=========================================================================*/
int main(int argc)
{	//permet de lancer l'application en fullscreen, grâce a l'appel de windows.h
    typedef BOOL (WINAPI *PFONCTION) (HANDLE,DWORD,PCOORD);
    HMODULE hDLL=LoadLibrary("kernel32.dll");
    PFONCTION SetDisplayMode = (PFONCTION) GetProcAddress(hDLL,"SetConsoleDisplayMode");
    HANDLE hconsole = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD coord;
    SetDisplayMode (hconsole,1,&coord); 
    //fin fullscreen

    int champ[m][n],nb,ele,l,c,coup;
	int couleur1,couleur2;
	bool visible[m][n];
	char vf,vm,menu;

	vf='-';
	vm='*';
	menu=' ';
	
    textcolor(30); //affiche la console sur la couleur 30 -ecriture en jaune, fond en bleu
    system("CLS"); //actualise la console, sinon la couleur reste sur "n" caractère imprimé

	do{
	ele=0;
	coup=0;

	nb= saisir_nb_mines(m, n);
	system("CLS");
	init_tab_2Dentier_0(champ, m, n);
	//placer_mines(champ, m, n, nb);
	initialiser_champ(champ, m, n, nb);
	init_tab2Dbool(visible,m,n);

		do{
			CLS(nb,ele,coup); //affiche les infos en haut du tableau
			afficher_champ(visible, champ, m, n, vf, vm);
			do{cout<<endl<<"Entrez la ligne du carre a rendre visible : ";		cin>>l;}while(l<0 && l>m);
			do{cout<<endl<<"Entrez la colonne du carre a rendre visible : ";	cin>>c;}while(c<0 && c>n);
			coup++;
			if(champ[l][c]!=9)
			{
				decouvrir_carre(visible, champ, m, n, l, c);
				ele=nb_el_visible(visible, m, n);
				CLS(nb,ele,coup); //permettra d'afficher les infos en sorti de boucle, cad sur l'état gagnant
			}
		}while((nb+ele<n*m) && (champ[l][c]!=9));
			if
			(champ[l][c]==9)
			{
			CLS(nb,ele,coup);
			decouverte_mines(visible, champ, m, n);
			afficher_champ(visible, champ, m, n, vf, vm);
			cout<<endl<<endl<<endl<<endl<<"-----   -----  -----   -----   |    | "<<endl;
			cout<<"|    |  |      |    |  |    \\  |    | "<<endl;
			cout<<"|----   |----  |----   |    |  |    | "<<endl;
			cout<<"|       |      |   \\   |    /  |    | "<<endl;
			cout<<"|       -----  |    \\  -----   ------ \a"<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl;
			quitter(menu); //continuer ou quitter
			}	
		else
			{
			decouverte_mines(visible, champ, m, n);
			afficher_champ(visible, champ, m, n, vf, vm);
		  cout<<endl<<endl<<endl<<endl<<"-------      /\\      -------   |\\    |   ------     *  * "<<endl;
			cout<<"|           /  \\     |         | \\   |   |          *  * "<<endl;
			cout<<"| |---|    /----\\    | |---|   |  \\  |   |-----     *  * "<<endl;
			cout<<"|     |   /      \\   |     |   |   \\ |   | "<<endl;
			cout<<"-------  /        \\  -------   |    \\|   ------     #  # \a \a"<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl;
			quitter(menu);
			}
	}while(m>0);

	//afficher_tab2Dentier(champ, m, n);

	return 0;
}

 Conclusion

Toute question est la bienvenue ^^

N'oubliez pas de voter :p

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !
  • dem.devTélécharger ce fichier [Réservé aux membres club]865 octets
  • main.cppTélécharger ce fichier [Réservé aux membres club]Voir ce fichier10 145 octets

Télécharger le zip


 Sources de la même categorie

Source avec Zip Source avec une capture PLUS OU MOINS par antho974
Source avec Zip Source avec une capture TETRIS EN C++ AVEC SDL par Marmalus
Source avec une capture DÉMINEUR SOUS TERMINAL par aom333
Source avec Zip JEU: MARIO SOKOBAN par astro53
Source avec Zip JEU PUISSANCE IV par ElendilAranwe

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture TETRIS EN C++ AVEC SDL par Marmalus
Source avec Zip JEU: MARIO SOKOBAN par astro53
Source avec Zip TOUR DE HANOI EN C par astro53
Source avec Zip Source avec une capture 2D GAME DIRECT X 9 par nanonavich
Source avec Zip JEU DES PETIT CHEVAUX par flamt

Commentaires et avis

Commentaire de vicenzo le 24/04/2009 17:42:41

lol, il faut modifier tout le code pour que ca puisse compiler en C...

Ce n'est pas un code "C" mais un pur code C++..

Commentaire de phenix22000 le 24/04/2009 17:59:39

A vrai dire il faut modifier tout les "cout" et "cin", c'est assez long je l'avoue lol. Mais pour ceux qui veulent le compiler, autant créer un projet en C++, ça permet d'avoir une visibilité et une exécution plus fluide qu'en C... ^^

Commentaire de vicenzo le 24/04/2009 18:02:53

nope, pas que les cin/cout....
rien d'autre te choques, c'est que tu dois pas souvent coder en C.

Commentaire de phenix22000 le 24/04/2009 20:52:53

Oui c'est très rare je n'ai jamais vraiment dépassé ce stade là jusqu'à maintenant :p... Il y a le booléen aussi je crois qui n'existe pas en C, c'est vrai que ce n'est plus vraiment du C. Au moins si ça peut en faire progresser quelques un qui débute c'est déjà ça ;)

Commentaire de exar le 25/04/2009 09:59:36

@vincenzo:
Ce n'est pas du "pur" c++, puisque celui-ci a été créé dans le but de développer en POO, ce qui n'est absolument pas le cas ici...
Néanmoins, c'est bien le langage utilisé ici.

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

fonction random en C [ par gemini010 ] slt a tous,je suis newbies en programation et un amis m'a demande de lui faire un programme pour un tirage au sort pour un tournois de foot... qqun s fonction random [ par greatspirit ] euh, comment on fait pour avoir la fonction qui génère auto matiquement un nombre entre 0 et 1 (communément appelée random pr d'otres langages -&gt; m fonstion random [ par Teclis01 ] Voil&#224; j'aimerais faire une fonction random qui renvoies 3 variables:1 long2 shortCes 3 variables de types different seront calcul&#233; de facon problème sur les nombres aléatoires [ par jacksonfive ] BonjourJe cherche la fonction qui tire un nombre aléatoire. Je souhaite créer un entier compris entre 2 et 14, j'avais pensé tirer un random entre 0 e pobleme de fonction [ par yacine93000 ] slt a tous voila mon problème un ami a moi ma passer le code source d'un d'un jeux qu'il a programmer mais quand je le colle dans code bloks le jeux n Help, la fonction random en C [ par yahyaabba ] Salut, Je veut que qqn m'aide pour ecrire le code source de la fonction aleatoire random, qui genère un nombre entiers aleatoire. Je n'ai aucun idée [ un programme qui en crée un autre [ par ritchou42 ] salut [^^yeuxenlair] je voulais savoir quel est la façon de procédé si je veux crée un programme sous win qui puissant générer un .exe en fonction du parametre de sortie d'une fonction [ par wislam2007 ] Salut je veux enregistrer des infos dans des paramertre de sortie d'une fonction (en c++)? Cordialement fonction test de connexion FTP [ par mohdaef ] Bonsoir Je recherche depuis un certain une fonction bouléène qui à un nom d'utilisateur, un mot de passe et une Adresse IP de serveur, donnés en para


Nos sponsors


Sondage...

CalendriCode

Février 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,702 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales