Jeux du démineur pour débutant

Soyez le premier à donner votre avis sur cette source.

Vue 14 838 fois - Téléchargée 998 fois

Description

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 / Exemple :


// 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

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

cs_vicenzo
Messages postés
179
Date d'inscription
mardi 16 août 2005
Statut
Membre
Dernière intervention
25 août 2010
-
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++..
phenix22000
Messages postés
11
Date d'inscription
jeudi 13 novembre 2008
Statut
Membre
Dernière intervention
28 mars 2012
-
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... ^^
cs_vicenzo
Messages postés
179
Date d'inscription
mardi 16 août 2005
Statut
Membre
Dernière intervention
25 août 2010
-
nope, pas que les cin/cout....
rien d'autre te choques, c'est que tu dois pas souvent coder en C.
phenix22000
Messages postés
11
Date d'inscription
jeudi 13 novembre 2008
Statut
Membre
Dernière intervention
28 mars 2012
-
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 ;)
cs_exar
Messages postés
286
Date d'inscription
vendredi 5 décembre 2003
Statut
Membre
Dernière intervention
22 avril 2012
1 -
@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.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.