TP9 : Code du jeu du démineur

Messages : 6 Date d'inscription : 30/11/2009 Age : 33 Localisation : AS

Des élèves d'autre groupe m'ont demandé comment j'avais réalisé le démineur, ainsi je mets en ligne le code du jeu du démineur du TP9 sur les tableaux à deux dimensions. C'est que le groupe H parce que c'est LE forum du groupe H.

J'ai utilisé deux tableaux : l'un pour l'emplacement des mines, l'autre pour le tableau de jeu. Tout d'abord, on initialise les tableaux avec le caractère X. Ensuite on place les mines & le jeu peut commencer!
Par la suite, le jeu s'arrête si on tombe sur une mine (M) ou si toutes les cases non-minées sont réalisés (soit N, la taille au carré des tableaux & MINE le nombre de mine : CASE NON-MINEE = N*N - MINE).

Pour ce qui aurait des questions sur la phase de recherche des mines à côté des cases (CBM comme ComBien de Mines). Cette partie nécessiterait d'être amélioré... Je verrai plus tard...

Code:: #include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define N 5
#define MINE 5
#define X 'X' // Case non découverte
#define M 'M' // Case minée

typedef char tab[N][N];

void Ini(tab,tab);
void AfficheT(tab);
void placeM(tab);
void jeu(tab,tab);
void CBM(tab,tab,int,int);

int main(){
tab TM; // Tableau des mines
tab TJ; // Tableau de jeu

srand(time(NULL));

Ini(TM,TJ); // Initialisation des tableaux (X)

placeM(TM); // Placement des mines (M)

jeu(TM,TJ); // Jeu

return 0;
}

void Ini(tab TM,tab TJ){
int i,j;

for(i=0;i<N;i++){
for(j=0;j<N;j++){
TM[i][j] = X;
TJ[i][j] = X;
}
}
}

void AfficheT(tab T){
int i,j;
int c = 0;

printf(" ");
for (c=0;c<N;c++){
printf("%d ",c);
}
c = 0;
printf("\n");

for(i=0;i<N;i++){
printf("%d ",c);
c++;
for(j=0;j<N;j++){
printf("%c ",T[i][j]);
}
printf("\n");
}
printf("\n");
}

void placeM(tab TM){
int i,j;
int cm;

for(cm=0;cm<MINE;cm++){
i = rand()%N;
j = rand()%N;
if (TM[i][j] == M){
while(TM[i][j] == M){
i = rand()%N;
j = rand()%N;
}
TM[i][j] = M;
}else{
TM[i][j] = M;
}
}
}

void jeu(tab TM,tab TJ){
int CL;
int CC;
int perdu = -1;
int compteur = 0; // Pour compter combien de cases ont été découverte
int nbcasesm = N*N - MINE; // Nombre de cases sans mine

printf("\nJeu du démineur\n\n");

while ((perdu == -1) && (compteur != nbcasesm)){
AfficheT(TJ);

printf("Ligne : ");
scanf("%d",&CL);
while ((CL < 0) || (CL >= N)){
printf("Ligne invalide : ");
scanf("%d",&CL);
}

printf("Colonne : ");
scanf("%d",&CC);
while ((CC < 0) || (CC >= N)){
printf("Colonne invalide : ");
scanf("%d",&CC);
}
printf("\n");

if (TM[CL][CC] == M){
perdu = 1; // HAHA! VOUS AVEZ PERDU!
printf("C'est une mine :O\n\n");
}else{
if (TJ[CL][CC] != X){
printf("Vous avez déjà rentré cette valeur.\n\n");
}else{
CBM(TM,TJ,CL,CC); // Recherche du nombre de mines aux alentours
compteur++; // Accrémentation du compteur de case
}
}
}

if (perdu == 1){
printf("Game Over\n\n");
}else{
printf("Vous avez gagné!\n\n");
}

}

void CBM(tab T,tab TJ,int i,int j){
int c = 0;

if ((i == N-1) && (j == N-1)){ // Case "En bas à droite"
if (T[i-1][j-1] == M){
c++;
}
if (T[i][j-1] == M){
c++;
}
if(T[i-1][j] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
}
}else if((i == 0) && (j == N-1)){ // Case "En haut à droite"
if (T[i][j-1] == M){
c++;
}
if (T[i-1][j-1] == M){
c++;
}
if (T[i-1][j] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
}
}else if((i == 0) && (j == 0)){ // Case "En haut à gauche"
if (T[i][j+1] == M){
c++;
}
if (T[i+1][j+1] == M){
c++;
}
if (T[i+1][j] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
}
}else if((i == N-1) && (j == 0)){ // Case "En bas à gauche"
if (T[i-1][j] == M){
c++;
}
if (T[i-1][j+1] == M){
c++;
}
if (T[i][j+1] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
}
}else if(i == 0){ // Ligne du haut
if (T[i][j-1] == M){
c++;
}
if (T[i+1][j-1] == M){
c++;
}
if (T[i+1][j] == M){
c++;
}
if(T[i+1][j+1] == M){
c++;
}
if (T[i][j+1] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
case 4:
TJ[i][j] = '4';
break;
case 5:
TJ[i][j] = '5';
break;
}
}else if(j == 0){ // Colonne de gauche
if (T[i-1][j] == M){
c++;
}
if (T[i-1][j+1] == M){
c++;
}
if (T[i][j+1] == M){
c++;
}
if(T[i+1][j+1] == M){
c++;
}
if (T[i+1][j] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
case 4:
TJ[i][j] = '4';
break;
case 5:
TJ[i][j] = '5';
break;
}
}else if(i == N-1){ // Ligne du bas
if (T[i][j-1] == M){
c++;
}
if (T[i-1][j-1] == M){
c++;
}
if (T[i-1][j] == M){
c++;
}
if(T[i-1][j+1] == M){
c++;
}
if (T[i][j+1] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
case 4:
TJ[i][j] = '4';
break;
case 5:
TJ[i][j] = '5';
break;
}
}else if(j == N-1){ // Colonne de droite
if (T[i-1][j] == M){
c++;
}
if (T[i-1][j-1] == M){
c++;
}
if (T[i][j-1] == M){
c++;
}
if(T[i+1][j-1] == M){
c++;
}
if (T[i+1][j] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
case 4:
TJ[i][j] = '4';
break;
case 5:
TJ[i][j] = '5';
break;
}
}else{ // N'importe où ailleurs
if (T[i][j+1] == M){
c++;
}
if (T[i+1][j+1] == M){
c++;
}
if (T[i+1][j] == M){
c++;
}
if (T[i+1][j-1] == M){
c++;
}
if (T[i][j-1] == M){
c++;
}
if (T[i-1][j-1] == M){
c++;
}
if (T[i-1][j] == M){
c++;
}
if (T[i-1][j+1] == M){
c++;
}
switch(c){ // Attribution de la valeur
case 0:
TJ[i][j] = '0';
break;
case 1:
TJ[i][j] = '1';
break;
case 2:
TJ[i][j] = '2';
break;
case 3:
TJ[i][j] = '3';
break;
case 4:
TJ[i][j] = '4';
break;
case 5:
TJ[i][j] = '5';
break;
case 6:
TJ[i][j] = '6';
break;
case 7:
TJ[i][j] = '7';
break;
case 8:
TJ[i][j] = '8';
break;
}
}
}

Bonne soirée Wink

Messages : 65 Date d'inscription : 27/11/2009 Localisation : Lannion

Y'a pas la version courte? king

Bon c'est sympa quand même, mais je vais y réfléchir et (peut-être) proposer plus court pirat

Le truc de oufff ^^ quand tu m'a dit que sa pouvais être plus court je pensais pas que c'était à ce point la ^^

Bon j'ai tester, ça fonctionne, mais voila ^^ je serais toi je reverrais la partie recherche des bombes parce que y a moyen de faire beaucoup plus court.

J'ai pas fais le TP, mais je donnerais surement une autre solution avant mercredi, jour du TP pour les H2.
Donc envoyez vos codes ici, tant qu'à faire si vous avez le courage de vous y mettre.

Messages : 6 Date d'inscription : 30/11/2009 Age : 33 Localisation : AS

Je pense que je devrais ajouter des conditions plus courtes. Je devrais faire un truc avec les 8 cases du genre : "Si il n'y a pas de débordement possible, je vérifie à nouveau si y'a une mine".

Ça raccoucira pas mal le code... En tout cas, il marche, c'est ce qui compte u_u

Pour ceux qui sont sèrieux et qui ont envie de terminer le TP, je suggère de procéder de la manière suivante qui est pour moi plus simple et logique que celle decrite dans le TP.

On garde l'idée des 2 tableaux, mais les deux tableaux devront être identiques.
Il y a donc un tableau d'affichage et un tableau qui contient l'emplacement des mines et le nombre de mines autours de chaque case.

Donc en 1 on initialise le tableauJeu, avec les caractères que vous voulez.
En deux on initialise le tableauMine en plassant les bombes aleatoirement dans le tableau de sorte qu'il y en ai 10.
Pour le calcul du nombre de bombes entourant chaques case la meilleurs methode est d'incrementer à chaque fois que l'on pose une bombe, chaque case qui l'entour, a condition que cette case ne soit pas une bombe et que l'on soit encore dans le tableau.
L'autre manière est de reparcourir le tableau en entier et d'incrémenter toute les cases qui entoure les bombes de 1, sous les même conditions qu'au dessu, sauf que c'est plus naïf, plus simple, mais moins optimisé.

Ensuite, si on suit la consigne on doit faire comme sa:
Ensuite on demande à l'utilisateur d'entrer l'abscisse et l'ordonnee, puis si c'est une bombe on a perdu sinon on dévoile la valeur de la case.

Si on veut faire un vrai démineur, si on tombe sur une case avec 0 bombes autours d'elle, on doit dévoiler toute les case adjacente récursivement.
C'est plus compliqué, si certains on réussi qu'ils poste le code =).

Pour finir le code ne devrait pas depasser 250 lignes ^^ aves une bonne présentation et des commentaires partout.