Buscaminas en C

BUSCAMINAS
Explicacin del juego

El juego consiste en despejar todas las casillas de una pantalla que no

oculten una mina.
Algunas casillas tienen un nmero, el cual indica la cantidad de minas
que hay en las casillas circundantes. As, si una casilla tiene el nmero 3,
significa que de las ocho casillas que hay alrededor (si no es en una
esquina o borde) hay 3 con minas y 5 sin minas. Si se descubre una
casilla sin nmero indica que ninguna de las casillas vecinas tiene mina
y stas se descubren automticamente.
Si se descubre una casilla con una mina se pierde la partida.

Planteamiento del problema

Se plantea la implementacin de este juego (buscaminas), bajo las reglas
planteadas en la explicacin, utilizando el lenguaje C y bajo el entorno de
programacin Dev C++.
Adems, se plantea la implementacin de 4 niveles de dificultad, los cuales se
detallan a continuacin:

Nivel: Fcil
Nmero de minas: 3
Tamao de Matriz: 7x7
Nivel: Medio
Nmero de minas: 12
Tamao de Matriz: 12x12
Nivel: Difcil
Nmero de minas: 50
Tamao de Matriz: 15x15
Nivel: Profesional
Nmero de minas: 70
Tamao de Matriz: 20x20

Buscaminas en C
1

Se deber mostrar paso a paso el proceso del juego, es decir, se pedir la fila y
la columna y en esa posicin se analizar si existe o no una mina, cuantas
minas existen alrededor de la misma, etc.

Anlisis del problema

En este juego bsicamente se utilizar matrices, donde se manipular cada
posicin de la misma, esto con el objetivo de determinar si en ella existe o no
una mina, tambin para determinar cuntas minas existen alrededor, lo cual se
deber mostrar mediante un nmero, tal como se explica en la parte superior
de este documento
Bsicamente el proceso ser similar para todos y cada uno de los niveles,
aunque obviamente variar en los parmetros que manejen cada uno de estos.

Diseo e implementacin
En cuanto al diseo de este juego, se debe aclarar que al desarrollar bajo el
lenguaje C no se cuenta con las facilidades de implementar una interfaz grfica
de manera simple como en otros leguajes, aunque C si permite simular una
interfaz grfica de momento no se manejara esto, sino que simplemente se
utilizara una interfaz por consola. Esto para el ingreso de datos, mostrar
resultados, etc.
El programa bsicamente consta de 2 mens
Men Principal:

Men Secundario:

Buscaminas en C
1

Esto est pensado de esta manera ya que en un futuro se puede aumentar ms

opciones en cualquiera de estos mens.

A continuacin, se explicar el desarrollo de solo uno de los niveles, ya que el

proceso es similar para todos los dems

Nivel: Fcil
Nmero de minas: 3
Tamao de Matriz: 7x7

Matriz Inicial

Se ingresa fila y columna

De esta manera se ira ingresando fila y columna y el programa analizara la

posicin ingresada. En otras palabras, se mostrar paso a paso este proceso.
Y al final, ya sea que se gane o que se pierda se mostrara la matriz solucin.
As:
(Cuando se gane la partida)

Buscaminas en C
1

(Cuando se pierda la partida)

Buscaminas en C
1

Bsicamente este es el proceso que se sigue en cada uno de los niveles,

obviamente cambiaran los parmetros: tamao de matriz, numero de minas,
etc., pero el proceso es similar.

Buscaminas en C
1
Funciones importantes usadas.
La siguiente funcin es la que contiene a todas las dems. En esta funcin se
inicia el juego, a continuacin, se presenta nicamente cuando es el primer
nivel. Como se mencion los otros niveles tiene un proceso similar.
//-----------------------------------------------------------------------------//Funcin para empezar el juego
//-----------------------------------------------------------------------------void empezarBuscaminas(int nivel){
//Nivel: Fcil
//Nmero de minas: 3
//Tamao de Matriz: 7x7
if(nivel == 1){
int numeroFilasDeNivel=FILAS;
int numeroColumnasDeNivel=COLUMNAS;
numeroFilasDeNivel=7;
numeroColumnasDeNivel=7;
int numeroMinasParaNivel = 3;
int x,y;
estado = ESTADO_EN_JUEGO;
numeroDeJugadasBuscaminas = 0;
inicializarArregloPrincipal(numeroFilasDeNivel, numeroColumnasDeNivel);
agregaMinasEnMatrizPrincipal(numeroMinasParaNivel, numeroFilasDeNivel, numeroColumnasDeNivel);
determinarNumerosMinasCercanas(numeroFilasDeNivel, numeroColumnasDeNivel);
while( estado == ESTADO_EN_JUEGO){ //estado en juego
imprimirMatriz(nivel, numeroFilasDeNivel, numeroColumnasDeNivel);
cout << "Fila: ";
cin >> x;
cout << "Columna: ";
cin >> y;
jugadaEnGrupo(x, y, numeroFilasDeNivel, numeroColumnasDeNivel);
numeroDeJugadasBuscaminas = contarJugadas(numeroFilasDeNivel, numeroColumnasDeNivel);
if( numeroDeJugadasBuscaminas == ( numeroFilasDeNivel*numeroColumnasDeNivel numeroMinasParaNivel) ){
estado = ESTADO_GANADOR;
}
}
if( estado == ESTADO_PERDEDOR){
imprimirMatriz(nivel, numeroFilasDeNivel, numeroColumnasDeNivel);
cout << endl;
cout << "FIN DEL JUEGO!!!!" << endl;
cout << "PERDISTE!!!!" << endl;
cout << endl;
cout << "Matriz Solucion: " << endl;
imprimiResultados(nivel, numeroFilasDeNivel, numeroColumnasDeNivel);
}else{
cout << endl;
cout << "FIN DEL JUEGO!!!!" << endl;
cout << "GANASTE!!!!" << endl;

Buscaminas en C
1

cout << endl;

cout << "Matriz Solucion: " << endl;
imprimiResultados(nivel, numeroFilasDeNivel, numeroColumnasDeNivel);
}
}

//-----------------------------------------------------------------------------//Funcin para iniciar la matriz principal de Juego

//-----------------------------------------------------------------------------void inicializarArregloPrincipal(int filasN1, int columnasN1){
int i,j;
for( i = 0; i < filasN1; i++){
for(j = 0; j < columnasN1; j++){
matrizJuego[i][j] = SIN_BOMBA;
jugadas[i][j] = false; //en la matriz de booleanos se define false
}

//cuando no se ha jugado en esta casilla

}
}

//-----------------------------------------------------------------------------//Funcin para agregar aleatoriamente las minas a la matriz principal de Juego

//-----------------------------------------------------------------------------void agregaMinasEnMatrizPrincipal(int numeroMinas, int filasN1, int columnasN1){
int i; //Contador de minas
int x;

//Posicin filas

int y;

//Posicin columnas

i = 1;
while( i <= numeroMinas){ //Generar posiciones aleatorias para minas
x = rand()%filasN1;
y = rand()%columnasN1;
matrizJuego[x][y] = BOMBA;
i++;
}

Buscaminas en C
1

//-----------------------------------------------------------------------------//Funcin para determinar los numeros que se mostraran

//esto segn las minas que esten cerca
//-----------------------------------------------------------------------------void determinarNumerosMinasCercanas(int filasN1, int columnasN1){
int i,j, numero;
for( i = 0; i < filasN1; i++){
for(j = 0; j < columnasN1; j++){
if( matrizJuego[i][j] == SIN_BOMBA){ //no tiene bomba
numero = contarNumeroMinasCercanas(i,j);
matrizJuego[i][j] = numero;
}
}
}
}

//-----------------------------------------------------------------------------//Funcin recursiva para determinar ubicaciones con minas

//y el numero de minas cercanas
//-----------------------------------------------------------------------------void jugadaEnGrupo(int x, int y, int filasN1, int columnasN1){
if( x >= 0 && x < filasN1 && y >= 0 && y < columnasN1 ){
jugadas[x][y] = true;
if( matrizJuego[x][y] == BOMBA){ //Cuando se hace una jugada y esta est en una mina, se cambia el estado
estado = ESTADO_PERDEDOR;
}else if( matrizJuego[x][y] == 0){//No existen minas alrededor de la posicin
for(int i = x-1; i < x+2; i++){
for(int j = y-1; j < y+2; j++){

Buscaminas en C
1

if( i >= 0 && i < filasN1 && j >= 0 && j < columnasN1 ){
if( matrizJuego[i][j] == 0 && !jugadas[i][j]){ //Existe mina en la posicin
jugadaEnGrupo(i,j, filasN1, columnasN1);
}else{
jugadas[i][j] = true;
}
}
}

}
}
}
}