Efectivamente, de acuerdo en el primer punto. Por ejemplo en esta situación:


si el jugador elige la posición (2,3) ¡¡¡BOOMMM!!!!, salta una mina. Y por qué lo sé, porrque tengo previamente la matriz de las posiciones de las minas, lo que responde a tu segundo punto:




Fíjate en la imagen de la respuesta anterior del juego que salen números, como en el mío, casillas levantadas=asteriscos y casillas planas=cuadraditos. Pero lo que yo propongo es un camino para que él termine la tarea, no hacerlo yo todo.

Como ves mi enfoque no está descaminado. como alegas en tu tercer punto.

Pero lo que no iba yo es a hacerle toda la tarea. Quedaba para él guardar la primera matriz, para no perder la situación de las minas originalmente, y usar otra para el engaño, así como el tema de pedir las coordenadas para el juego propiamente.

Tan sólo es un esbozo del juego, aunque creo que me animaré a terminarlo para el nietillo.

Y no, no te estabas perdiendo nada. Era un inicio de la tarea que tenía que realizar xuhipoint , yo sólo pretendía desatascarle el arranque.

María, llega un momento en que la complejidad de un programa crece hasta que termina enredándose uno mismo en su propio trabajo, jeje. Para evitar eso debes trabajar de manera modular, es decir, divide el programa en pequeñas partes funcionales que puedan integrarse entre sí.

Ahora hago unos comentarios. Es muy válida la recomendación de eferion, si estás en C++ usa endl en lugar de '\n'. Por otra parte perdón a los que puedan discrepar pero me parece más lógico que la matriz sea considerada de enteros y no de char, pues al fin y al cabo contendrá números (1 si hay bomba, 0 si no hay). Soy partidario de que una función auxiliar sea la encargada de decidir qué caracteres se van a mostrar en pantalla, en lugar de que dichos caracteres sean almacenados directamente en la matriz. Y como verás, este enfoque te evitar tener que hacer conversiones y operaciones complicadas como:

Matriz[fil][col]=cont[fil][col]+48;   (????????)


Tomando como base el código que presentaste, y depurándolo eliminé unas cuántas líneas redundantes por aquí y por allá, también como te dije sacar del main() rutinas que pueden definirse aparte, hasta quedar un procedimiento principal breve, limpio y sencillo (como debe ser):

int main(void) {
 
   int dim;
   int i, j;
 
   cout << "Introduzca la dimension de la matriz: ";
   cin >> dim;
 
   int **A = new int *[dim];
   for (i = 0; i < dim; i++)
      A[i] = new int [dim];
   for (i = 0; i < dim; i++)
      for (int j = 0; j < dim; j++)
         A[i][j] = 0;
 
   /* indicar donde van las minas, e imprimir */      
   colocar_minas( A, dim);
   imprimir( A, dim, 1);
 
   /* descubrir las casillas */
   descubrir_casillas( A, dim);
}

donde me tomé el atrevimiento de cambiar el nombre "Matriz" por simplemente "A".

Ahora, la función auxuliar de colocar las minas se encarga de rellenar la matriz (en lugar de hacerlo el main()). En lo particular me pareció un poco pesado e innecesario que el usuario tenga que decir de antemano cuántas bombas hay. En lugar de ello lo modifiqué para que él te vaya preguntando si quieres meter otra mina, y sigue hasta que respondas 'n'. El código:

void colocar_minas (int **A, int dim) {
 
   int i, fil, col;
   char op;
 
   cout << endl << "*** Colocando las minas ***" << endl << endl;
 
   op = 's';
   do {
      do {
         cout << "Introduzca fila: ";
         cin >> fil;
      } while (fil < 1 || fil > dim);
      fil = fil - 1;
 
      do {
         cout << "Introduzca columna: ";
         cin >> col;
      } while (col < 1 || col > dim);
      col = col - 1;
 
      A[fil][col] = 1;
 
      /* imprimimos, para que el usuario vea como va quedando */
      imprimir( A, dim, 0);
 
      do {
         cout << "Otro? s/n: ";
         cin >> op;
      } while ( op != 's' && op != 'S' && op != 'n' && op != 'N' );
 
   } while ( op == 's' || op == 'S' );
}

También me pareció más adecuado separar la utilidad de contar las minas que rodean una casilla en una función aparte int contar_minas( int **A, int dim, int i, int j ).

Ahora vamos a la parte delicada, y lo que creó el meollo: si en la matriz reemplazas el valor de cada casilla (1 si hay bomba y 0 si no hay) por la suma de las casillas adyacentes, entonces pierdes el valor original. ¿Cómo hacer? Una solución sería crear dos matrices, pero desperdicia espacio de memoria. Otra alternativa es modificar la función:

imprimir(int **A, int dim, int estilo)

que recibe una matriz A de 1's y 0's, pero donde el tercer argumento estilo permite definir tres modos posibles de funcionamiento:

• estilo = 0, hace que se imprima '*' donde hay bomba y '0' donde no hay
• estilo = 1, hace que se impriman las sumas de las casillas circundantes, en lugar de bomba/no-moba
• estilo = 2, es para cuando el usuario va descubriendo las casillas. Imprime la suma circundante si la casilla no ha sido destapada, '0' si ha sido destapada y no hay bomba, y '*' si se destapó y hay una bomba (el juego termina).

La idea es usar el estilo 0 cuando estás rellenando la matriz, el 1 cuando terminaste de llenar, y el 2 cuando vas destapando las casillas. Pero resumes los tres en una sola función, de un modo sintético y elegante.

Sin embargo surge un problema delicado. Si una casilla no tiene bomba y no ha sido destapada se representa por la suma circundante. Pero si no tiene bomba y ha sido destapada, se representa por un '0'. ¿Cómo distinguir un caso de otro? Como dije antes una solución (ineficiente) es crear una segunda matriz que se vaya actualizando según las casillas que el usuario vaya descubriendo.
Mejor es apelar a un "truco" que usamos los programadores. Si miras bien, hasta ahora hemos usado 2 valores posibles para cada celda de la matriz A, esto es, 0 y 1. Quedan otros valores disponibles, con los que podemos representar otros significados. Podríamos asignar el valor -1 para la casilla que tenga una bomba que ha sido descubierta (boom!!, termina el juego), y el 2 para la casilla que ha sido destapada y no tiene bomba. Así quedaría:

• A[ i][j] = -1, si hay una bomba y fue destapada (termina el juego)
• A[ i][j] = 0, si no hay bomba, y no ha sido destapada
• A[ i][j]) = 1, si hay bomba, pero no ha sido destapada
• A[ i][j] = 2, si no hay bomba, y fue destapada

La función de imprimir, con las tres posibilidades quedaría:

void imprimir( int **A, int dim, int estilo) {
 
   int i, j;
 
   for (i = 0; i < dim; i++) {
   cout << "\t\t" ;
      for (j = 0; j < dim; j++) {
         /* aqui decidimos como queremos imprimir */
         switch (estilo) {
            /* solo mina / no-mina */
            case 0:
               if ( A[i][j] == 1 )
                  cout << " * ";
               else
                  cout << " 0 ";
               break;
            /* contar las minas que rodean */
            case 1:
               cout << ' ' << contar_minas( A, dim, i, j ) << ' ';
               break;
            /* a medida se van descubriendo las minas */
            case 2:
               if ( A[i][j] == -1 )
                  cout << " * ";      /* boom, jeje */
               else if ( A[i][j] == 0 || A[i][j] == 1 )   
                  cout << ' ' << contar_minas( A, dim, i, j ) << ' ';
               else if ( A[i][j] == 2 )
                  cout << " 0 ";
            break;
         }
      }
      cout << endl << endl;
   }
   cout << endl << endl;
}

Ahora, hay que tener cuidado cuando codificamos la función de sumar los adyacentes. Recuerda que se debe sumar cualquier bomba (destapada o no) o sea, el valor 1 ó -1 en la matriz. Por lo tanto:

/* Cuenta la cantidad de minas que rodean a una posicion dada de la matriz,
 * incluyendo al elemento propio */
int contar_minas( int **A, int dim, int i, int j ) {
 
   int k, l, contador;
 
   contador = 0;
   for ( k = -1; k < 2; k++) {
      for ( l = -1; l < 2; l++) {
         if (i+k >= 0 && j+l >= 0 && i+k < dim && j+l < dim) 
            if ( A[i+k][j+l] == 1 || A[i+k][j+l] == -1)
               contador ++;
      }
   }
 
   return contador;
}

Ya lo que quedaría sería definir la función que permite al usuario ir destapando las casillas a su gusto. Si destapa una bomba, pierde. De lo contrario, el juego continúa hasta que destapa todas las que no tienen bomba en cuyo caso gana. Este código te lo muestro al final, junto con el programa completo.

El código a continuación ya es funcional, está listo para copiar, compilar y ejecutar.

NOTA. Téngase en cuenta que en el juego buscaminas real hay características que nuestro programa aún no posee.

#include <iostream>
 
using namespace std;
 
void imprimir (int **A, int dim, int estilo);
void colocar_minas (int **A, int dim);
int contar_minas (int **A, int dim, int i, int j);
void descubrir_casillas (int **A, int dim);
 
int main(void) {
 
   int dim;
   int i, j;
 
   cout << "Introduzca la dimension de la matriz: ";
   cin >> dim;
 
   int **A = new int *[dim];
   for (i = 0; i < dim; i++)
      A[i] = new int [dim];
   for (i = 0; i < dim; i++)
      for (int j = 0; j < dim; j++)
         A[i][j] = 0;
 
   /* indicar donde van las minas, e imprimir */      
   colocar_minas( A, dim);
   imprimir( A, dim, 1);
 
   /* descubrir las casillas */
   descubrir_casillas( A, dim);
}
 
/* Permite al usuario ir colocando las minas. Para seguir colocando, 
 * responder 's' al final, de lo contrario termina. */
void colocar_minas (int **A, int dim){
 
   int i, fil, col;
   char op;
 
   cout << endl << "*** Colocando las minas ***" << endl << endl;
 
   op = 's';
   do {
      do {
         cout << "Introduzca fila: ";
         cin >> fil;
      } while (fil < 1 || fil > dim);
      fil = fil - 1;
 
      do {
         cout << "Introduzca columna: ";
         cin >> col;
      } while (col < 1 || col > dim);
      col = col - 1;
 
      A[fil][col] = 1;
 
      /* imprimimos, para que el usuario vea como va quedando */
      imprimir( A, dim, 0);
 
      do {
         cout << "Otro? s/n: ";
         cin >> op;
      } while ( op != 's' && op != 'S' && op != 'n' && op != 'N' );
 
   } while ( op == 's' || op == 'S' );
}
 
/* Imprime la matriz en varios estilos:
 *
 *  0: Indican simplemente donde hay minas y donde no.
 *  1: Indica cuantas minas rodean a cada casilla (incluyendo a si misma)
 *  2: Como se muestra a medida que se descubren las casillas.
 *     El valor -1 imprime una bomba, para los valores entre 0 y 9 imprimen
 *     la suma circundante, y el 10 se imprime como 0.
 */
void imprimir( int **A, int dim, int estilo) {
 
   int i, j;
 
   for (i = 0; i < dim; i++) {
   cout << "\t\t" ;
      for (j = 0; j < dim; j++) {
         /* aqui decidimos como queremos imprimir */
         switch (estilo) {
            /* solo mina / no-mina */
            case 0:
               if ( A[i][j] == 1 )
                  cout << " * ";
               else
                  cout << " 0 ";
               break;
            /* contar las minas que rodean */
            case 1:
               cout << ' ' << contar_minas( A, dim, i, j ) << ' ';
               break;
            /* a medida se van descubriendo las minas */
            case 2:
               if ( A[i][j] == -1 )
                  cout << " * ";      /* boom, jeje */
               else if ( A[i][j] == 0 || A[i][j] == 1 )   
                  cout << ' ' << contar_minas( A, dim, i, j ) << ' ';
               else if ( A[i][j] == 2 )
                  cout << " 0 ";
            break;
         }
      }
      cout << endl << endl;
   }
   cout << endl << endl;
}
 
/* Cuenta la cantidad de minas que rodean a una posicion dada de la matriz,
 * incluyendo al elemento propio */
int contar_minas( int **A, int dim, int i, int j ) {
 
   int k, l, contador;
 
   contador = 0;
   for ( k = -1; k < 2; k++) {
      for ( l = -1; l < 2; l++) {
         if (i+k >= 0 && j+l >= 0 && i+k < dim && j+l < dim) 
            if ( A[i+k][j+l] == 1 || A[i+k][j+l] == -1)
               contador ++;
      }
   }
 
   return contador;
}
 
/* Permite al usuario ir descubriendo casillas del tablero, y si se 
 * encuentra una mina, pierde !!! */
void descubrir_casillas( int **A, int dim ) {
 
   int i, j;
   char terminar;
 
   cout << endl << "*** Ahora descubriendo las casillas ***" << endl << endl;
 
   imprimir( A, dim, 2);
 
   terminar = 'n';
   do {
      do {
         cout << "Introduzca fila: ";
         cin >> i;
      } while (i < 1 || i > dim);
      i = i - 1;
 
      do {
         cout << "Introduzca columna: ";
         cin >> j;
      } while (j < 1 || j > dim);
      j = j - 1;
 
      if ( A[i][j] == 1) {
         /* encuentra mina: pierde !!! */
         A[i][j] = -1;
         imprimir( A, dim, 2 );
         cout << endl << "Boom!!!, ha perdido" << endl;
         terminar = 's';
      }
      else {
         /* sigue jugando */
         A[i][j] = 2;
         imprimir( A, dim, 2 );
      }
 
      /* Nota: 0 significa casilla sin bomba y sin descubrir.
       *       2 significa casilla sin bomba y ya descubierta.
      /* El programa termina si no quedan por descubrir casillas 
       * sin bombas (casillas con el valor 0) */
      if ( terminar == 'n' ) {
         terminar = 's';
         for (i = 0; terminar == 's' && i < dim; i++)
            for (j = 0; terminar == 's' && j < dim; j++)
               if ( A[i][j] == 0 ) terminar = 'n';
 
         if ( terminar == 's' ) {
            cout << endl << "Felicitaciones, ha ganado !!!" << endl;
            imprimir( A, dim, 0);
         }
      }
 
   } while ( terminar == 'n' );
}

Jejejeje.

A mí es que me da muchísima pereza ponerme a escribir código cuando veo que el que pregunta no ha puesto ni un mísero main .

Cuando veo que el autor del hilo se lo ha currado un mínimo y no ha puesto código copiado ( a veces canta mucho ), la cosa cambia y me vuelco más.

Eso sí, hay veces que me levanto con mejor humor y no tengo problemas en escribir el quijote si hace falta. Pero por norma general...

Ok xuhipoint, pero por favor mantennos al tanto de lo que has hecho y cómo va funcionando. Es la manera de corresponder a los que nos hemos involucrado en este tema, y quisiéramos saber que lo has terminado y si te ha ido bien  .

Yo me uní a este foro porque precisamente rescata el espíritu anteriormente prevaleciente entre la comunidad de programadores, que era la solidaridad (bueno, hasta que llegó Microsoft y echó a perder todo, jaja). Es la misma filosofía GNU. Los programadores debemos ser personas sumamente humanitarias.

Ahora, pienso que un programa de esta complejidad, aunque para nosotros no parezca mucho, sí lo es para alguien que esté comenzando. Lleva asignación dinámica de memoria, manejo de matrices, elementos delicados donde si te pones a trabajar en "solitario" te vas a enredar y equivocar. No está mal que recibir ayuda.

Así que por favor ten en cuenta las recomendaciones generales que te hemos hecho. Todos hemos pasado por lo mismo y ya ganamos experiencia con ésto. En particular, yo señalaría con mucho énfasis:

• Modulariza el código. De otro modo terminas teniendo lo que se llama "espagueti". Por ejemplo, en la función de asignar las minas tenías que ahí mismo calculabas cuántas minas rodeaban una casilla para mostrar las sumas. Así llegabas a tener cuatro (4) ciclos anidados, un for dentro de for, dentro de for, dentro de for, y empieza a volverse complicado. Debes tener una función exclusiva para colocar las minas, otra par sumar las minas adyacentes, otra para imprimir la matriz, etc. "Divide y vencerás".
• El formato de declaración for (int i = 0 ....) donde el tipo de la variable contador está "auto-declarado" en lo particular me parece algo desaconsejable aquí. Tengo entendido (no se si me equivoco) que primero ésto es sólo válido en C99, y segundo al hacer ésto la "vida" o alcance de la variable es sólo dentro del bloque o ciclo en cuestión donde se declara, por lo que no puedes reutilizar el contador en otra parte del código. Declara las variables contador al inicio de la definición de la función.
• Decide para los elementos de la matriz un tipo "consistente" de datos, que luego no tengas que estarlo cambiando o transformando. Si es char, que sea char. Si en entero, que sea entero. Pero no que sea char, el cual luego lo estás transformando a entero, y de nuevo a char, etc. Esto es fuente probable de errores, es inseguro, y por un pequeño descuido te puede echar a perder todo el programa.

Esto es en general lo que puedo comentar. Trabaja como quieras, pero sigue dichos consejos y no se si leosansan y eferion quieren añadir otros basados en su experiencia.