PRCTICA FINAL OBLIGATORIA DE LA ASIGNATURA

INFORMTICA APLICADA
PARA LA TITULACIN DE GRADO EN
INGENIERA MECNICA (UPCT)

CURSO 2012-2013

Implementacin del juego del BUSCAMINAS

Pedro Mara Alcover Garau Primera versin, 26 de noviembre, 2012. Segunda versin, 27 de noviembre de 2012.

(Todo depende de a dnde quiera llegar uno. Y es que cuando uno se pone llega!) nimo!

INTRODUCCIN
El Buscaminas es un juego de ordenador para un solo jugador. El objetivo del juego es despejar un campo minado sin detonar ninguna mina. El tablero de juego del Buscaminas es un rectngulo de filas y columnas: tantas como elija el jugador. En cada posicin de fila y columna hay una celda o casilla, inicialmente cubierta. En algunas de esas celdas se ocultan minas. El jugador debe despejar todas las celdas del tablero excepto aquellas que ocultan una mina. Si el jugador da la orden de levantar una celda con mina, entonces pierde el juego. Algunas casillas, entre las que no son celdas de mina, tienen asignado un valor numrico: ese valor indica el nmero de minas que circundan a la posicin de esa celda. Cada celda tiene hasta un mximo de otras ocho que la rodean, y por tanto el valor mximo que podr tomar una celda es 8. Habr casillas que no tendrn ninguna mina a su alrededor: a esas casillas no se les asigna nmero alguno (o se les asigna el valor 0). Cuando el jugador levanta una celda sin valor numrico y sin mina es inmediato saber que las ocho celdas que la rodean tampoco tienen mina: por eso, cuando el jugador selecciona una celda sin valor, el juego desvela automticamente todas aquellas celdas que, a partir de sa seleccionada, se encuentren tambin sin valor, hasta levantar todas aquellas que tienen un valor numrico distinto de 0. Supongamos el tablero (al descubierto) que se muestra en la Figura 1. Evidentemente, el jugador desconoce la informacin que se recoge en esa figura: lo que realmente se le muestra es el cuadro de la Figura 2.

c00 f00 f01 f02 f03 f04 f05 f06 f07 f08 f09 0 1 1 1 0 0 1 1 1 0

c01 0 1 M 2 1 1 2 M 1 0

c02 0 1 2 M 1 1 M 3 2 0

c03 1 1 1 1 1 1 2 M 1 0

c04 M 2 1 1 0 0 1 1 1 0

c05 2 3 M 1 0 0 0 0 0 0

c06 2 M 4 2 0 0 0 0 0 0

c07 2 M M 1 0 0 0 0 0 0

c08 1 2 2 1 0 1 1 1 0 0

c09 0 0 0 0 0 1 M 1 0 0

Figura 1.: Tablero (10 x 10 al descubierto) de una partida del Buscaminas.

c00 f00 f01 f02 f03 f04 f05 f06 f07 f08 f09 -

c01 -

c02 -

c03 -

c04 -

c05 -

c06 -

c07 -

c08 -

c09 -

Figura 2.: Tablero (10 x 10) de inicio para el juego del Buscaminas.

Supongamos que el usuario decide destapar la celda que est en la fila 0 y la columna 3. Le indicar al ordenador esos dos parmetros (de fila y columna) y le indicar que lo que desea hacer con esa celda es levantarla. Entonces, el tablero adoptar, en esa zona, el aspecto de la Figura 3: mostrar el valor 1 de esa posicin levantada, indicando que en torno a esa posicin hay una mina y slo una.

c00 f00 f01 -

c01 -

c02 -

c03 1 -

c04 -

c05 -

Figura 3.: Aspecto parcial del Tablero del Buscaminas cuando se ha levantado la celda en posicin fila 0 y columna 3. El valor 1 indica que en torno a esta posicin hay una mina (y slo una). sta puede estar localizarla en la fila 0, columnas 2, 4; o en la fila 1, columnas 2, 3, 4.

Supongamos ahora que el usuario selecciona la posicin fila 9 y columna 9. Como se puede ver en la Figura 1, esa celda tiene el valor 0 (evidentemente, esa informacin que nosotros ahora conocemos, no est disponible para el jugador). Al seleccionar, pues, el jugador, esa celda, el tablero deber presentar la apariencia mostrada en Figura 4. Desde luego, el inicio del juego queda sujeto al azar. Pudiera ser que el usuario hubiera escogido inicialmente la celda de fila 0 y columna 4 (ver en Figura 1): en ese caso, hubiera explosionado la mina y el juego hubiera terminado y el jugador habra perdido la partida. Pero una vez el juego ha comenzado quedan pocos flecos para el azar, y casi todas la celdas van quedando claras aunque no se hayan descubierto. Por ejemplo, en la

Figura 4 es fcil darse cuenta que tenemos una mina en las posiciones fila 2, columna 7; fila 7, columna 3; o fila 6, columna 9. Entonces el jugador puede seleccionar esas posiciones como mina, para recordarle dos cosas: (1) que esas posiciones no deben ser levantadas; y (2) que si all hay una mina, en todas las celdas lindantes con ella y que tengan ya descubierto el valor 1 podemos ya saber que todas las dems celdas que las rodeen estn limpias de minas. En el Cuadro 5 se muestran esas tres celdas sealadas como minas.

c00 f00 f01 f02 f03 f04 f05 f06 f07 f08 f09 1

c01 1

c02 2

c03 1 1 1 1 2 1

c04 1

c05 1

c06 2

c07 1

c08 1 2 2 1 1

c09

1 1

1 1 1

1 1

Figura 4.: Aspecto que adquiere el Tablero cuando se he seleccionado la Fila y Columna 9, donde tenamos un valor 0. Como se explica en esta memoria, al levantar una celda con valor 0, se debe proceder a levantar, de forma automtica, todas sus celdas adyacentes. Si alguna de sus adyacentes vuelve a tener el valor 0, entonces, de nuevo, el programa deber proceder a levantar todas sus celdas adyacentes.

Puede ocurrir que el jugador marque una celda como mina pero que, en realidad, no sea tal. El juego, en ese caso, deber seguir: el programa marcar esa celda como mina, pero no terminar mientras que el jugador se desdiga y marque esa celda, finalmente, como celda libre de minas. De todas formas, si el jugador marca equivocadamente una celda como celda con mina, es muy posible que pierda el juego, porque en algn momento no le saldrn las cuentas de las celdas numeradas al descubierto, y pensar que no hay mina donde realmente s la haba. Desde luego, el entorno ms cmodo para desarrollar el juego del Buscaminas sera con una herramienta grfica, donde el usuario seleccionara las celdas como limpias o como posibles minas pulsando sobre ellas el botn izquierdo o derecho del ratn. Desde luego eso no se puede hacer en este curso donde los alumnos no conocen cmo desarrollar la parte grfica del software. Pero la algoritmia en cualquier caso es la misma, y el programa puede implementarse para ser ejecutado en una ventada de consola. As se les propone

que lo hagan. Adems, se les pide que implementen la aplicacin de tal manera que el tablero pueda tener cualquier tamao de filas y columnas.

c00 f00 f01 f02 f03 f04 f05 f06 f07 f08 f09 1

c01 1

c02 2

c03 1 1 1 1 2 <?> 1

c04 1

c05 1

c06 2

c07 <?> 1

c08 1 2 2 1 1

c09

1 <?> 1

1 1 1

1 1

Figura 5.: Aspecto del tablero cuando se han marcado tres celdas con el indicativo de que, en ellas se halla una mina. Esta marca no garantiza que, de hecho, haya una mina en esa posicin. Es una marca que puede poner el jugador, porque l piensa que en esa celda hay una mina. Si est en lo cierto, entonces esa marca le ser de gran ayuda. Si estaba equivocado, es muy probable que esta marca le lleve a considerar que no hay mina en una posicin que, de hecho, s la hay.

CMO IMPLEMENTAR ESTA APLICACIN

TIPOS DE DATO
La primera cuestin a decidir es la de la forma en que se va a codificar la informacin del tablero: porque en cada una de sus celdas deberemos consignar dos informaciones: (1) por un lado, su contenido: la informacin sobre si en esa celda hay o no hay una mina; y, si no la hay, el valor numrico calculado para esa celda en funcin del nmero de minas que la rodean; (2) por otro lado deberemos indicar sobre cada celda su estado: oculta, levantada, marcada como mina, o mina reventada, lo que lleva tambin consigo el fin del juego. Para lograr que una celda mantenga dos informaciones tenemos algunas soluciones. La ms sencilla es crear una estructura de datos, es decir, un nuevo tipo de dato. Podra tener la siguiente forma:
typedef struct { short int valor_celda; short int estado_celda; }Celda;

As hemos creado un nuevo tipo de dato, llamado Celda. Con este tipo de dato, podemos hacer referencia a uno u otro campo, mediante el operador punto. Vemoslo con un ejemplo. Si creamos una variable de tipo Celda:
Celda mi_celda;

Ahora podemos hacer referencia a uno u otro valor de esa variable. Lo hacemos de la siguiente manera:
mi_celda.valor_celda, para referirnos al primer campo; mi_celda.estado_celda, para referirnos al segundo campo.

Esta gua trabajar con el tipo de dato Celda. No hay ningn problema en que cualquier alumno decida trabajar la informacin de otra manera (ms adelante se muestra cmo). Quiz con lo explicado en esta pgina sea suficiente para comprender cmo se manejan esos nuevos tipos de dato. Si desea conocer mejor la creacin y el manejo de las estructuras, entonces quiz sea conveniente que trabaje unas pocas pginas del captulo 20 del manual de Teora. As pues, la declaracin de la matriz del tablero podra tener el siguiente aspecto:
#define _FILAS #define _COLUMNAS Celda tablero[_FILAS][_COLUMNAS]; 10 10

Donde la dimensin puede fijarse mediante directivas define, o se puede solicitar al usuario que, al inicio del juego, decida el tamao que debe tener el tablero sobre el que va a jugar. En esta presentacin, consideraremos todo el tiempo que el programa se realiza sobre los valores de filas y columnas definidas en estas directivas. No supone complicacin alguna sobre lo que aqu se dir el hecho de que esos dos valores ( _FILAS y _COLUMNAS) sean dos variables cuyo valor introduce el usuario en tiempo de ejecucin. Otra forma de crear el tablero para el Buscaminas es con un array de tres dimensiones. Sera como crear dos matrices iguales en tamao (en filas y columnas): una de ellas dedicada a los valores del tablero, y la otra dedicada a codificar el estado de cada una de las posiciones. Sera algo as:
#define _FILAS 10 #define _COLUMNAS 10 short int tablero[2][_FILAS][_COLUMNAS];

As, cuando quisiramos hacer referencia al valor de la celda, trabajaramos con la matriz tablero[0][i][j], para valores de i entre 0 y _FILAS y de j entre 0 y _COLUMNAS. Y cuando quisiramos hacer referencia al estado de la celda, trabajaramos con la matriz tablero[i][i][j], con los mismos posibles valores para los ndices i y j. Aunque esta memoria est presentada de acuerdo al primer esquema de codificacin del tablero (mediante la estructura Celda) bien puede interpretarse toda la informacin de acuerdo con esta segunda forma. Baste tener en cuenta que, de acuerdo con estas dos formas de codificar el tablero del Buscaminas, tenemos que decir tablero[i][j].valor_celda es equivalente a decir tablero[0][i][j], y que decir tablero[i][j].estado_celda es equivalente a decir tablero[1][i][j]. En los folios que siguen se le ofrece una gua para que le ayude a resolver la prctica. Decida ya cul de los dos esquemas de codificacin del tablero va a elegir, y no cambie su decisin a mitad de trabajo. Hay otras diversas formas de codificar el tablero. Algunas lograran un tablero mucho ms reducido en la memoria, con el que trabajaramos mediante operadores a nivel de bit. Es una filosofa sencilla, pero requiere oficio en el uso de estos operadores. No las vamos a mostrar ahora aqu, para evitar el desconcierto.

VALORES PREDEFINIDOS
Otra Cuestin es la coleccin de valores que daremos a las celdas en el campo de control. Es decir, una vez tenemos creado el tablero Qu valores pueden tomar cada una de las 100 celdas, en el campo correspondiente a tablero[f][c].estado_celda (o tablero[1][i][j]? Porque esa variable, de tipo short, no tiene sentido que pueda tomar cualquier valor, si en realidad hemos definido slo cuatro valores posibles, que son: (1) celda oculta; (2) celda levantada; (3) celda marcada como mina; o (4) celda con mina reventada. Lo ms sencillo sera crear un nuevo tipo de dato enumerado, pero no hemos visto esto en clase de teora (Captulo 20 del manual). Vamos a proponer una solucin que no exige presentar ms materia que no hemos presentado en las clases tericas de la asignatura. Podemos crear una serie de valores con directivas define:
#define #define #define #define _OCULTA _LEVANTADA _MINA_MARCADA _MINA_REVENTADA 1 2 3 4

Respecto a los valores que pueden adoptar en las distintas posiciones del array el campo tablero[f][c].valor_celda ( tambin tablero[0][i][j]) ya hemos dicho que stos pueden ser cualquiera entre 0 y 8, ambos inclusive. Pero tambin debemos indicar qu cdigo dar a una celda que tenga una mina; en ese caso la informacin que debemos consignar en ella no es cuntas minas encuentra a su alrededor, sino simplemente que esa celda corresponde a una mina. Podemos, por ello, crear un valor (distinto de cualquier entero entre 0 y 8) que signifique que estamos ante una mina. Por ejemplo:
#define _MINA 0x7FFF

Respecto a las sucesivas selecciones que el jugador ir haciendo, es necesario conocer si la seleccin de una nueva celda se realiza para que sta quede destapada, o si lo que pretende el jugador es marcar esa celda como posible mina. As, cada nueva entrada del jugador, deber recoger tres valores: los dos primeros indicarn la fila y la columna de la celda seleccionada; el tercero deber indicar el motivo por el que el jugador ha seleccionado la celda. Convendr crear otros dos valores para esa opcin de seleccin:
#define _SELECCION_LEVANTAR_CELDA #define _SELECCION_MARCAR_MINA 1 2

Con todo esto, ya tenemos creados los tipos de dato y tambin hemos acotado los valores posibles que puede adoptar una celda del tablero del buscaminas. Ms adelante, en esta memoria, podr encontrar algunos nuevos literales creados para la gestin de la informacin en la aplicacin: ya los ver. Podemos ahora comenzar a implementar el cdigo.

FUNCIONES
Para resolver este trabajo se sugiere que se declaren y se definan una serie de funciones. Entre ellas, enumeramos tres a continuacin, en Cdigo 1.

Cdigo 1.: Declaracin de algunas funciones, posiblemente necesarias para resolver esta aplicacin, de las que vamos a mostrar, en esta memoria, una posible implementacin. Se presentan los prototipos de las funciones segn cada una de las dos formas de codificar el tablero que hemos propuesto anteriormente.

void inicializarTablero (short fil, short col, Celda tablero[fil][col]); void pintarTablero (short fil, short col, Celda tablero[fil][col]); void eliminarCerosAdyacentes (short f, short c, short fil, short col, Celda tablero[fil][col]);

void inicializarTablero (short fil, short col, short tablero[2][fil][col]); void pintarTablero (short fil, short col, short tablero[2][fil][col]); void eliminarCerosAdyacentes (short f, short c, short fil, short col, short tablero[2][fil][col]);

FUNCIN inicializarTablero()
La primera de estas funciones inicializa el cuadro del tablero. Adems de decidir cuntas minas se van a insertar en el tablero, deber hacer otras dos cosas: (1) Elegir, de forma aleatoria algunas de las celdas y asignarles el papel de minas dentro del juego. Evidentemente, la funcin deber vigilar que no se inserte dos veces una mina en una misma celda.

10

(2) Recalcular, ante cada nueva mina insertada, el valor de todas las celdas que circundan a la celda donde se ha insertado la nueva mina. Para ello se deber tener en cuenta que: a. Las celdas del cuadro ubicadas en los bordes del tablero no estn rodeadas por 8 celdas sino por algunas menos: 5 3, segn esa celda sea lateral o uno de los cuatro vrtices. Al hacer el recuento se deber, pues, vigilar para no hacer violacin de memoria, y no se intente asignar valores a hipotticas posiciones del tablero con ndices negativos o mayores que el tamao de cada dimensin. b. Las celdas marcadas como mina no deben sufrir modificacin alguna. Una posible implementacin de esta primera funcin podra ser la que se propone en Cdigo 2.

Cdigo 2.: Implementacin de la funcin inicializarTablero, que asigna valores iniciales al tablero del buscaminas. Mostramos slo la implementacin para la codificacin del tablero mediante el tipo de dato matriz de dos dimensiones de tipo Celda. Para el caso de la matriz tridimensional de tipo short, bastara, como ya se explic previamente, cambiar cualquier referencia a tablero[f][c].estado_celda por tablero[1][f][c]; y cualquier referencia a tablero[f][c].valor_celda por tablero[0][f][c].
#include <stdlib.h> #include <time.h> // para la generacin de aleatorios. // para la funcin time()

// Definicin ... void inicializarTablero(short fil, short col, Celda tablero[fil][col]) { // fil: nmero de filas del tablero. // col: nmero de columnas del tablero. short numeroMinas; // minas a insertar en el tablero short contadorMinas; // contador de las minas ya insertadas short f, c; // fila y columna actual en cada momento. // Inicializamos la semilla del generador de pseudoaleatorios. srand(time(NULL)); // Determinamos de forma aleatoria el nmero de minas que se // van a insertar en el tablero: un mnimo de 10 y algunas ms // entre 1 y un 5% del producto de filas por columnas. numeroMinas = 10 + (rand() % (fil * col) / 20 + 1); // Inicializamos el tablero: Todas las celdas ocultas // y con valor igual a 0.

11

Cdigo 2.: Funcin inicializarTablero (Cont).

for(f = 0 ; f < fil ; f++) { for(c = 0 ; c < col ; c++) { tablero[f][c].estado_celda = _OCULTA; tablero[f][c].valor_celda = 0; } } // Comienza la insercin de minas for(contadorMinas = 0 ; contadorMinas < numeroMinas ; ) { // inicio bloque 1 f = rand() % fil; // fila aleatoria. c = rand() % col; // columna aleatoria. // Debemos verificar que en esa posicin no hay, ya, una mina // Si no hay mina habr que realizar dos operaciones: if(tablero[f][c].valor_celda != _MINA) { // inicio bloque 2 short ff, cc; // (1) Insercin de una nueva mina tablero[f][c].valor_celda = _MINA; contadorMinas++; // Una nueva mina insertada // (2) Incrementar en 1 todas las celdas adyacentes. for(ff = f - 1 ; ff <= f + 1 ; ff++) { // inicio bloque 3 for(cc = c - 1 ; cc <= c + 1 ; cc++) { // inicio bloque 4 // Verificamos que esa celda existe if((ff >= 0) && (cc >= 0) && (ff < fil) && (cc < col)) { // inicio bloque 5 // Verificamos, en cada celda adyacente, que NO hay ya una mina if(tablero[ff][cc].valor_celda != _MINA) { // inicio bloque 6 tablero[ff][cc].valor_celda++; } // fin bloque 6 } // fin bloque 5 } // fin bloque 4

12

Cdigo 2.: Funcin inicializarTablero (Cont).

} // fin bloque 3 } // fin bloque 2 } // fin bloque 1 return; }

FUNCIN pintarTablero()
La segunda funcin se encarga de mostrar el tablero por pantalla. Aqu proponemos una versin que imprimir en pantalla de comando un cuadro similar al mostrado en la Figura 2. En Cdigo 3 puede ver una posible implementacin. Quiz le convendr crear alguna otra funcin que imprima en tablero en algunos casos especiales (o modificar ligeramente sta): cuando el jugador haya logrado ganar la partida, y se pueda entonces mostrar ya el cuadro con toda la informacin, tal y como se muestra en la Figura 1.

Cdigo 3.: Implementacin de la funcin pintarTablero, que muestra por pantalla el tablero del buscaminas. De nuevo, recuerde que si usted ha elegido definir el tablero como un array tridimensional, nicamente bastar con que cambie cualquier referencia a tablero[f][c].estado_celda por tablero[1][f][c]; y cualquier referencia a tablero[f][c].valor_celda por tablero[0][f][c]. La declaracin del array en el parmetro de entrada, como ya se vio en la declaracin del prototipo, se obtiene al cambiar Celda tablero[fil][col] por short tablero[2][fil][col].

#include <stdlib.h> #include <stdio.h>

// Para la funcin system(). // Para la funcin printf().

// Definicin ... void pintarTablero(short fil, short col, Celda tablero[fil][col]) { short f, c; // // // // Limpiamos la pantalla. Para ello invocamos a la funcin system, que ejecuta una orden desde el sistema operativo. La orden "cls" limpia la pantalla de comandos en Windows. La orden clear limpia la pantalla de comandos en Linux y Mac.

13

Cdigo 3. Funcin pintarTablero (Cont.).

system("cls"); system("clear"); printf("\n\t\t");

//

// Mostramos por pantalla la numeracin de cada columna... for(c = 0 ; c < col ; c++) { printf(" c%02hd ", c); } // Mostramos ahora, una a una, todas las filas... for(f = 0 ; f < fil ; f++) { // inicio bloque 1 // Primero el nmero de la fila ... printf("\n\n\tf%02hd\t", f); // Ahora todas las columnas de la fila actual ... for(c = 0 ; c < col ; c++) { // inicio bloque 2 // Si la celda est oculta, no la mostramos. if(tablero[f][c].estado_celda == _OCULTA) { // inicio bloque 3 printf(" - "); } // fin bloque 3. // Si la celda est levantada, la mostramos... // Puede ser que tengamos que mostrar una MINA. // O puede ser que tengamos que mostrar un valor numrico. else if(tablero[f][c].estado_celda == _LEVANTADA) { // inicio bloque 3 // Si hay una mina (opcin imposible, pero ah va): if(tablero[f][c].valor_celda == _MINA) { // inicio bloque 4 printf(" M "); } // fin bloque 4 // Hay un valor numrico distinto de cero. else if(tablero[f][c].valor_celda != 0) { // inicio bloque 4 printf(" %hd ", tablero[f][c].valor_celda); } // fin bloque 4

14

Cdigo 3. Funcin pintarTablero (Cont.).

// Hay un valor numrico igual a cero. else { // inicio bloque 4 printf(" "); } // fin bloque 4 } // fin bloque 3 // Si la celda est marcada como mina, mostramos una seal... else if(tablero[f][c].estado_celda == _MINA_MARCADA) { // inicio bloque 3 printf(" <?> "); } // Fin bloque 3 // Si la celda es una mina que hemos "pisado"... else if(tablero[f][c].estado_celda == _MINA_REVENTADA) { // inicio bloque 3 printf(">EXP<"); } // fin bloque 3 } // fin bloque 2 } // fin bloque 1 printf("\n\n\n"); return; }

FUNCIN eliminarCerosAdyacentes()
La tercera funcin la hemos llamado eliminarCerosAdyacentes, y se encarga de levantar todas las celdas que estn en torno a una de valor cero que haya sido levantada previamente. Ya se ha explicado en la introduccin el porqu de esta operacin. En Cdigo 4 puede ver una posible implementacin de esta funcin. En este caso, ofrecemos una solucin recursiva (cfr. Captulo 15 del manual de referencia de teora): sera til que comprendiera bien este cdigo. Con stas, tiene ya tres funciones necesarias dentro de la aplicacin que deseamos implementar. No se le va a mostrar aqu ms cdigo (bueno: en realidad algo ms le facilito ms adelante. Ya lo ver). Le corresponde ahora a usted continuar con el desarrollo de nuestro proyecto. Se le facilitan, sin embargo, algunas orientaciones. Posiblemente, con este cdigo aqu mostrado, tiene usted ya resuelta ms del 50% de la

15

aplicacin: la correspondiente a la parte ms complicada de la implementacin. Haga un esfuerzo por entender estas implementaciones aqu mostradas: le darn muchas pistas sobre cmo resolver todo lo que falta; y le ayudar a aprender a programar.

Cdigo 4.: Implementacin recursiva de la funcin eliminarCerosAdyacentes, que levanta todas las celdas de valor cero, adyacentes a una seleccionada y de valor cero. Por tercera y ltima vez, recuerde que si usted ha elegido definir el tablero como un array tridimensional, nicamente bastar con que cambie cualquier referencia a tablero[f][c].estado_celda por tablero[1][f][c]; y cualquier referencia a tablero[f][c].valor_celda por tablero[0][f][c]. La declaracin del array en el parmetro de entrada, como ya se vio en la declaracin del prototipo, se obtiene al cambiar Celda tablero[fil][col] por short tablero[2][fil][col].
// Esta funcin es invocada cuando la celda marcada // por la fila f y la columna c tiene el valor 0. // Definicin ... void eliminarCerosAdyacentes (short f, short c, short fil, short col, Celda tablero[fil][col]) { // f, c: fila y columna de la celda de valor cero con la que trabajamos. // fil, col: dimensiones del tablero. short ff, cc; // para recorrer las filas y columnas del tablero. // Levantamos la celda seleccionada, (indicada por f y c). // Esta operacin es importante para evitar concurrencia infinita: tablero[f][c].estado_celda = _LEVANTADA; // // // // Y ahora levantamos sus adyacentes, todas ellas sin mina. Adems, si en estas adyacentes encontramos una celda con valor 0 de nuevo invocamos la funcin para levantar todas las de su alrededor. for(ff = f - 1 ; ff <= f + 1 ; ff++) { // inicio bloque 1 for(cc = c - 1 ; cc <= c + 1 ; cc++) { // inicio bloque 2 // Verificamos que la celda existe: if((ff >= 0) && (cc >= 0) && (ff < fil) && (cc < col) && ((ff != f) || (cc != c))) { // inicio bloque 3 // Si la celda ya ha sido levantada antes, entonces no // que volver a procesarla.

16

Cdigo 4.: Funcin eliminarCerosAdyacentes (Cont.).

if(tablero[ff][cc].estado_celda != _LEVANTADA) { // inicio bloque 4 // Levantamos la celda tablero[ff][cc].estado_celda = _LEVANTADA; // Y si la celda vale 0, volvemos a invocar // a la funcin de forma recursiva o recurrente. if(tablero[ff][cc].valor_celda == 0) { inicio bloque 5 eliminarCerosAdyacentes (ff, cc, fil, col, tablero); } // fin bloque 5 } // fin bloque 4 } // fin bloque 3 } // fin bloque 2 } // fin bloque 1 return; }

17

ARCHIVOS DE CDIGO
Le recomendamos que, dentro del proyecto que se va a crear y donde se recoger todo el cdigo de la aplicacin, cree 3 archivos:
funciones.h: donde se recogern todas las definiciones de tipo de dato, y todas las

directivas define. Tambin debern recogerse todas las declaraciones de todas las funciones.
funciones.c: donde se recogen todas las implementaciones de las funciones declaradas en funciones.h. Este archivo deber tener, al inicio, la siguiente directiva: #include "funciones.h"

Y tambin aquellas inclusiones de archivos de cabecera que se necesiten para el uso de las funciones en ese archivo.
main.c: donde se recoge la funcin principal. Este archivo tambin deber recoger la inclusin del archivo de cabecera funciones.h.

18

SUGERENCIAS SOBRE LA IMPLEMENTACIN DE OTRAS FUNCIONES

Desde luego, necesita ms funciones, adems de aquellas tres que se le han sugerido en un apartado anterior. Hay otras dos que son necesarias para la comunicacin con el usuario. (1) Una encargada de recoger cada nueva entrada que ejecuta el usuario del juego implementado. Cada entrada debe estar formada por tres valores: uno que indique la fila de la nueva celda seleccionada; otro que indique la columna de esa nueva celda seleccionada; y un tercer valor que indique si el usuario elige esa celda para ser destapada o para ser marcada como mina. Esa funcin podra tener, por ejemplo, la declaracin sugerida en Cdigo 5.

Cdigo 5.: Declaracin de la funcin nuevaEntrada(). Se muestra la declaracin segn cada una de las dos formas que hemos propuesto para la creacin del tablero del Buscaminas.

short nuevaEntrada (short*f , short*c, short fil , short col , Celda tablero[fil][col]);

short nuevaEntrada (short*f , short*c, short fil , short col , short tablero[2][fil][col]);

Esta funcin devolver el motivo de la seleccin de una celda determinada: o para que sta sea levantada, o para que sta sea marcada como posible mina. Pero, dnde recoger la funcin el valor de la fila y de la columna seleccionada?: pues en los parmetros f y c, primero y segundo de la funcin y que aqu se pasan por referencia! (cfr. Captulos 16 y 17 del manual de referencia de teora, o Captulo 10 del manual de prcticas). Esta funcin tiene una definicin muy sencilla: debe nicamente recoger esos tres valores: dos de ellos deber dejarlos asignados en las variables f y c, y el tercero (_SELECCION_MARCAR_MINA _SELECCION_LEVANTAR_CELDA), deber devolverlo con la sentencia return. (2) Otra funcin deber encargarse de analizar la entrada recibida. Es decir, deber buscar la celda seleccionada (operacin que se habr realizado con la funcin anterior) y deber decidir qu valor dar al estado de la celda:

19

a. Si la celda ha sido seleccionada con la opcin _SELECCION_MARCAR_MINA, entonces se le deber dar el estado de la celda el valor _MINA_MARCADA. b. Si la celda ha sido seleccionada con la opcin _SELECCION_LEVANTAR_CELDA, entonces se deber dar al estado de la celda uno de los siguientes valores: i. Si la celda es una mina, entonces el estado ser _MINA_REVENTADA. En este caso, nuestra funcin deber devolver un valor que indique que la partida ha terminado y que el jugador ha perdido. ii. Si la celda es un espacio con un valor numrico distinto de cero, entonces el estado deber ser _LEVANTADA. En este caso, nuestra funcin deber devolver un valor que indique que la partida sigue. iii. Si la celda es un espacio con el valor numrico cero, entonces deber invocar a la funcin eliminarCerosAdyacentes(), que ya ha sido presentada. Adems, la funcin deber determinar si ya se han logrado levantar todas las celdas (excepto, claro est, las que corresponden a cada una de las minas), y en ese caso, deber devolver un valor que indique que el juego ha terminado. O deber devolver un valor que indique que el juego contina, si an no se ha finalizado. O deber devolver un valor que indique juego perdido, si el jugador ha levantado una celda que contena una mina. De nuevo, pues, se hace conveniente crear una serie de valores que sern los de retorno de esta funcin:
#define _EXPLOSION #define _JUEGO_TERMINADO #define _JUEGO_EN_MARCHA 1 2 3

20

UNA NUEVA AYUDA

Como posiblemente vaya perdido, se le ofrece una nueva ayuda, y se le facilita una posible implementacin de la funcin nuevaEntrada antes presentada. Puede verla en Cdigo 6.

Cdigo 6.: Funcin analizarEntrada(). Recuerde (ya se ha repetido hasta la saciedad) cmo cambiar este cdigo en el caso de que haya elegido usted trabajar con un tablero en forma de matriz tridimensional.
// // // // Funcin que recibe como parmetros la opcin seleccionada por el jugador (levantar o marcar celda), la fila y la columna de la celda seleccionada, y las dimensiones de la matriz del tablero as como el tablero.

short analizarEntrada (short op, short f, short c, short fil, short col, Celda tablero[fil][col]) { short ff, cc; switch(op) { case _SELECCION_MARCAR_MINA: tablero[f][c].estado_celda = _MINA_MARCADA; break; case _SELECCION_LEVANTAR_CELDA: if(tablero[f][c].valor_celda == 0) { eliminarCerosAdyacentes(f, c, fil, col, tablero); } else if(tablero[f][c].valor_celda == _MINA) { tablero[f][c].estado_celda = _MINA_REVENTADA; return _EXPLOSION; } else { tablero[f][c].estado_celda = _LEVANTADA; } }

21

Cdigo 4.: Funcin analizarEntrada (Cont.).

for(ff = 0 ; ff < fil ; ff++) { for(cc = 0 ; cc < col ; cc++) { if(tablero[ff][cc].valor_celda != _MINA && tablero[ff][cc].estado_celda != _LEVANTADA) { return _JUEGO_EN_MARCHA; } } } return _JUEGO_TERMINADO; }

22

INDICACIONES FINALES
Se le ha facilitado mucha ayuda: se le ha explicado paso a paso qu debe hacer el cdigo que usted deber implementar. Se le ha facilitado mucha parte de este cdigo. Pero no tiene todo el trabajo hecho. Deber comprender, si de verdad quieren emplearlo, el cdigo que se le facilita. Deber ser capaz de ensamblarlo, y lograr montar felizmente un cdigo completo que ofrezca al usuario la posibilidad de jugar al cuadro mgico. Y le queda, cmo no, implementar la funcin main. Desde luego, puede afrontar el trabajo propuesto sin hacer uso alguno de lo que en esta gua se les dice. Siempre hay alumnos que as lo hacen, y siempre logro ver, gracias a ellos, soluciones originales (a m me lo parecan). No se desanimen ante el enunciado de la prctica. Que sea largo no es un argumento contra l, sino ms bien a favor: si fuera ms largo, quiz sera porque an les facilitaba ms cdigo. Pero no puedo darles ms, porque poco es lo que falta para tenerlo terminado. Insisto: si no comprenden el cdigo que se les facilita, no podrn saber cmo ensamblarlo. Y tampoco sabrn qu funciones nuevas haran falta para completar la implementacin. Tampoco pueden adivinar, sin conocimientos, el diseo de la funcin main. No deje este trabajo para mas tarde. No decida que es demasiado difcil para usted. Fundamentalmente porque no es cierto. nimo!

23