EI96 - ESTRUCTURA DE INFORMACIN

EI96 - ESTRUCTURA DE INFORMACIN

Docente - tutor: Lic. Carlos Ruiz De La Cruz Melo
e-mail: ruizdelacruzmelo@uigv.edu.pe



Tarea Acadmica 2014-2
Tema: Busca Minas






FECHA DE PRESENTACIN: 19 06 2014.
ESTUDIANTE:
YERREN HUIMA, MARCOS TEODORO
CODIGO DE ESTUDIANTE: 174521300
SEMESTRE ACADMICO IV

2014









Introduccin

JUEGO DE BUSCAMINAS PROGRAMADO EN DEV C++

Como ya es conocido el juego del Buscaminas fue inventado por Robert Donner en
el ao de 1989. El objetivo en el juego es despejar un campo con minas sin detonar
ninguna de ellas.

El juego se hizo popular debido a las versiones que vinieron y vienen con el
sistema operativo Microsoft Windows desde su versin 3.1.

La idea del juego es despejar todas aquellas casillas de una ventana que no
oculten una mina.
Ciertas casillas tienen asignadas un nmero, este nmero indica las minas que se
encuentran adyacentes a esta casilla. Por ejemplo si una casilla tiene el nmero 2,
entonces de las ocho casillas adyacentes a esta (si no es en una esquina o borde)
hay 2 con minas y 6 sin minas. Si se descubre una casilla y esta se encuentra
vaca, esto indica que las casillas vecinas no tiene mina y estas se descubren
automticamente.
Al descubrir una casilla con una mina se pierde el juego.
Se gana el juego cuando se logra destapar todo el campo sin detonar una casilla
con una mina.


MTODOS
Ahora pasamos a describir las 17 funciones que se implementaron para lograr tener el
juego funcionado:
void nombrePrograma(): Esta funcin nos permite mostrar el nombre del
programa en la ventana de ejecucin.
void limpiarMatriz(int Matriz[][30],int N): Esta funcin realiza un recorrido de una
matriz de enteros para almacenar en ella ceros, en trminos informticos se est
realizando una limpieza de dicha matriz para no tener problemas ms adelante al
momento de ejecutar nuestro juego.
void generarMarcoBuscaminas(int N): Esta funcin como su nombre lo dice nos
permite generar y colocar el marco que rodear a todas las casillas o celdas del
juego Buscaminas.
void colocarDigitoHorizontal(int N): Esta funcin se implement para colocar el
nmero que le corresponde a una determinada columna en la ventana de
ejecucin.
void colocarDigitoVertical(int N): Esta funcin al igual que la anterior se
implement para colocar el nmero que le corresponde a una fila en la ventana de
ejecucin.
int validarDimensionBuscaminas(): Esta funcin permite validar que el tamao
del juego Buscaminas sea mayor o igual que nueve y menor o igual que veinte, a
su vez ayuda a validar que el nmero de filas sea igual al numero de columnas
(una matriz cuadrada). Retorna un valor entero el cual ser el valor tanto de las
filas como de las columnas.
int validarNumeroMinas(int N): Con esta funcin se valida que el nmero de
minas no sea menor que veinte ni mayor que el nmero de casillas/2. Retorna un
valor entero el cual representa el nmero de minas que van a existir en el campo
de juego.
void generarBuscaminas(char A[][30],int N,int m): Esta funcin nos permite
generar las minas que son representadas por un "*" y colocarlas en el campo de
juego.
void contarMinasBuscamicas(char A[][30],int N): La finalidad de esta funcin es
contar las cantidad de minas existentes en las casillas adyacentes a una
determinada casilla y colocar el valor de la cantidad dentro de esta.
void leerColocarDigitoBuscaminas(char A[][30],int i,int j,int n): Esta funcin es
usada en la funcin contarMinasBuscaminar() para colocar el valor de la cantidad
de minas existentes en las casillas adyacentes a la casilla analizada.
void reportarBuscaminasSinSolucion(char A[][30],int N): Esta funcin nos
permite mostrar las casillas iniciales del juego Buscaminas todas cubiertas dentro
del marco generado.
void matrizBanderaAuxiliar(int B[][30],char A[][30],int N): Con esta funcin se
almacenan los valores de cada casilla en una matriz auxiliar la cual servir para ir
mostrando los valores o mina de las casillas destapadas.
void reportarBuscaminasCasillaDestapada(int N,int X, int Y,int B[][30],char
A[][30]): Esta funcin nos permite reportar el campo del juego Buscaminas con las
respectivas casillas destapadas luego de seleccionar una posicin para ver el valor
de dicha casilla.
int verificarCasillaDestapada(char[][30],int X,int Y,int M): Esta funcin permite
verificar una jugada, si la casilla descubierta no contiene mina se puede seguir
jugando caso contrario termina el juego. Retorna 1 si la casilla no contiene mina y
retorna -1 si la casilla contiene una mina.
void mostrarContenidoCasillaDestapada(int B[][30],char A[][30],int N): Esta
funcin nos permite mostrar el contenido de cada casilla o casillas al momento de
realizar una jugada.
void verificarAdyacente(int B[][30],int i, int j): Esta funcin nos ayuda a verificar
las casillas adyacentes a una casilla vaca para ser destapadas en el caso de que
sigan vacas o no contengas una mina. Una casilla vaca en el en el juego esta
representada por un "0".
int ContarMinasSinDestapar(int N,int B[][30]): Funcin que ayuda a verificar si el
jugador a ganado, esto se realiza contando las casillas sin destapar. Si el nmero
de casillas sin destapar es igual al nmero de minas el jugador a ganado.





























CONCLUSIONES

Finalmente la imagen obtenida son:

Imagen 1


Imagen 2


Imagen 3


Imagen 4


Imagen 5


Imagen 6




RESULTADOS
#include <conio.h>
#include <iostream>
#include "Buscaminas.h"
#include "CONSOLA.H"
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

using namespace std;
/*FUNCION PARA MOSTRAR EL NOMBRE
DEL PROGRAMA EN PANTALLA*/

void nombrePrograma() {
cout<<"JUEGO BUSCAMINAS"<<endl;
}

/*FUNCION PARA LIMPIAR UNA
MATRIZ DE ENTEROS*/

void limpiarMatriz(int Matriz[][30],int N) {
int i;
int j;
for(i=0;i<N;i++) {
for(j=0;j<N;j++) {
Matriz[i][j]=0;
}
}
}

/*FUNCION PARA COLOCAR POSICION
DE LAS COLUMNAS*/

void colocarDigitoHorizontal(int N) {
int i=0;
for(i=1;i<=N;i++) {
if(i<10) {
cout<<i<<" ";
}else {
cout<<i<<" ";
}
}
}

/*FUNCION PARA COLOCAR POSICION
DE LAS FILAS*/

void colocarDigitoVertical(int N) {
int i=0;
gotoxy(0,3);
for(i=1;i<=N;i++) {
cout<<i<<"\n\n";
}
}

/*FUNCION PARA VALIDAR LAS
DIMENSIONES DEL BUSCAMINAS*/

int validarDimensionBuscaminas() {
int N,M;
do {
gotoxy(33,0);
nombrePrograma();
gotoxy(16,4);
cout<<"Ingrese numero de columnas del buscaminas: ";
cin>>N;
gotoxy(16,7);
cout<<"Ingrese el numero de filas del buscaminas: ";
cin>>M;
if((M!=N)||(M+N<18)||(M+N>40)) {
gotoxy(11,10);
cout<<"la matriz debe ser cuadrada, dimensiones(min=9 y max=20)\n\n";
getch();
}
system("cls");
} while((M!=N)||(M+N<18)||(M+N>40));
return(N);
}

/*FUNCION QUE PERMITE VALIDAR EL NUMERO DE MINAS*/

/////////////////////////////////////////////////////////
// MINIMO "20" MINAS //
// MAXIMO NUMERO DE CASILLEROS ENTRE ENTRE DOS(N*N/2) //
/////////////////////////////////////////////////////////

int validarNumeroMinas(int N) {
int minas=0;
do {
gotoxy(33,0);
nombrePrograma();
gotoxy(29,3);
cout<<"ingrese numero de minas: ";
cin>>minas;
if(minas<=9 ||minas>N*N/2) {
gotoxy(13,5);
cout<<"Valor no aceptado(min=10 minas y max=#casillas/2 minas)"<<endl;
getch();
}
system("cls");
} while(minas<=9 || minas>N*N/2);
return(minas);
}

/*FUNCION PARA GENERAR BUSCAMINAS*/

void generarBuscaminas(char A[][30],int N,int m) {
int i;
int j;
int k;
int a;
int b;
k=0;
srand((unsigned) time(NULL));
while(k<m) {
A[rand()%N][rand()%N]='*';
k=0;
for(i=0;i<N;i++) {
for(j=0;j<N;j++) {
if(A[i][j]=='*') {
k=k+1;
}else {
A[i][j]='0';
}
}
}
}
}

/*FUNCION QUE COLOCA EL DIGITO
CORRESPONDIENTE EN UNA CASILLA*/

void leerColocarDigitoBuscaminas(char A[][30],int i,int j,int n) {
if(n==1) {
A[i][j]='1';
}else {
if(n==2) {
A[i][j]='2';
}else {
if(n==3) {
A[i][j]='3';
}else {
if(n==4) {
A[i][j]='4';
}else {
if(n==5) {
A[i][j]='5';
}else {
if(n==6) {
A[i][j]='6';
}else {
if(n==7) {
A[i][j]='7';
}else {
if(n==8) {
A[i][j]='8';
}
}
}
}
}
}
}
}
}

/*FUNCION PARA COLOCAR LOS DIGITOS
EN EL INTERIOR DEL BUSCAMINAS*/

void contarMinasBuscamicas(char A[][30],int N) {
int i;
int j;
int k;
int n;
k=0;
n=0;
for(i=0;i<N;i++) {
for (j=0;j<N;j++) {
if(A[i][j]!='*') {
k=j-1;
n=0;
while(k<=j+1) {
if (A[i-1][k]=='*') {
n=n+1;
}
if(A[i][k]=='*' && k!=j) {
n=n+1;
}
if(A[i+1][k]=='*') {
n=n+1;
}
k=k+1;
}
if(n!=0) {
leerColocarDigitoBuscaminas(A,i,j,n);
}
}
}
}
}

/*FUNCION QUE REPORTA EL BUSCAMINAS SIN SOLUCION*/

void reportarBuscaminasSinSolucion(char A[][30],int N) {
int i=0,j=0,k=0;
for(i=0;i<N;i++) {
if(i<j) {
cout<<endl<<endl;
cout<<" ";
}
for(j=0;j<N;j++) {
cout<<"";
if(j<N-1) {
cout<<" ";
}
}
}
}

/*FUNCION QUE PERMITE LLENAR UNA MATRIZ AUXILIAR
LA CUAL SERVIRA PARA MOSTRAR LAS CASILLAS
DESTAPADAS DEL BUSCAMINAS*/

void matrizBanderaAuxiliar(int B[][30],char A[][30],int N) {
limpiarMatriz(B,N);
int i=0,j=0,k=0;
for(i=0;i<N;i++) {
for(j=0;j<N;j++) {
if(A[i][j]=='0') {
k=j-1;
while(k<=j+1) {
if(0<=k && k<N && i<N-1) {
B[i+1][k]=-1;
}
if(0<=k&&k<N) {
B[i][k]=-1;
}
if(0<=k && 0<i && k<N) {
B[i-1][k]=-1;
}
k=k+1;
}
}else {
if(B[i][j]!=-1) {
B[i][j]=1;
}
}
}
}
}


/*FUNCION PARA ANALIZAR LAS CASILLAS
ADYACENTES A UNA CASILLA VACIA*/

void verificarAdyacente(int B[][30],int i, int j) {
B[i][j]=0;
if(B[i][j-1]==-1) {
verificarAdyacente(B,i,j-1);
}
if(B[i][j+1]==-1) {
verificarAdyacente(B,i,j+1);
}
if(B[i-1][j]==-1) {
verificarAdyacente(B,i-1,j);
}
if(B[i+1][j]==-1) {
verificarAdyacente(B,i+1,j);
}
}

/*FUNCION QUE REPOTRA EL BUSCAMINAS
CON CASILLA DESTAPADA*/

void reportarBuscaminasCasillaDestapada(int N,int n,int m,int B[][30],char A[][30]) {
int i=0,j=0;
int X;
int Y;
X=n-1;
Y=m-1;
for(i=0;i<N;i++) {
for(j=0;j<N;j++) {
if(i==X && j==Y) {
if(B[i][j]==-1 && A[i][j]=='0') {
verificarAdyacente(B,i,j);
i=N;
}else {
B[i][j]=0;
i=N;
}
}
}
}
}

/* FUNCION QUE PERMITE SEGUIR JUGANDO MIENTRAS
NO SE ENCUENTRE UNA MINA*/

//////////////////////////////////////////////////////////
// RETORNA 1 SI LA CASILLA NO CONTIENE UNA MINA //
// RETORNA -1 SI LA CASILLA ESTA OCUPADA POR UNA MINA //
//////////////////////////////////////////////////////////

int verificarCasillaDestapada(char A[][30],int n,int m,int N) {
int i,j,X,Y;
int digito=0;
X=n-1;
Y=m-1;
for(i=0;i<N;i++) {
for(j=0;j<N;j++) {
if(i==X&&j==Y) {
if(A[i][j]!='*') {
digito=1;
i=N;
}else {
digito=-1;
i=N;
}
}
}
}
return(digito);
}

/*FUNCION QUE PERMITE MOSTRAR
LO QUE CONTIENE EN UNA CASILLA*/

void mostrarContenidoCasillaDestapada(int B[][30],char A[][30],int N) {
int i=0,j=0;
for(i=0;i<N;i++) {
if(i<j) {
cout<<endl<<endl;
cout<<" ";
}
for(j=0;j<N;j++) {
if(B[i][j]==0) {
cout<<A[i][j];
if(j<N-1) {
cout<<" ";
}
}else {
cout<<"";
if(j<N-1) {
cout<<" ";
}
}
}
}
}

/*FUNCION QUE PERMITE VERIFICAR SI EL JUGAGOR A
GANADO CONTANDO LAS CASILLAS SIN DESTAPAR*/

//////////////////////////////////////
// SI EL NUMERO DE CASILLAS TAPADAS //
// ES IGUAL AL NUMERO DE MINAS EL //
// JUGADOR A GANADO //
//////////////////////////////////////

int ContarMinasSinDestapar(int N,int B[][30]) {
int i=0,j=0;
int cont;
cont = 0;
for(i=0;i<N;i++) {
for(j=0;j<N;j++) {
if(B[i][j]==1) {
cont=cont+1;
}
}
}
return(cont);
}

/*FUNCION QUE GENERARA EL MARCO DEL BUSCAMINAS*/

void generarMarcoBuscaminas(int N) {
clrscr();
gotoxy(2,2);
cout<<"";
gotoxy(3,2);
for(int i=0;i<(N+(N-1)*2)+1;i++) {
cout<<"";
}
gotoxy(N+N*2+1,2);
cout<<"";
gotoxy(N+N*2-1,3);
for(int j=1;j<2*N;j++) {
gotoxy(N+N*2+1,j+2);
cout<<"";
}
gotoxy(N+N*2+1,2*N+2);
cout<<"";
gotoxy(N,N-1);
for(int k=N+N*2;k>1;k--) {
gotoxy(k,2*N+2);
cout<<"";
}
gotoxy(2,2*N+2);
cout<<"";
gotoxy(1,2*N-1);
for(int l=2*N+1;l>=3;l--) {
gotoxy(2,l);
cout<<"";
}
}



BIBLIOGRAFIA

BRAUNSTEIN, Silvia L. y GIOIA, Alicia: Introduccin a la programacin y a las Estructuras
de Datos. Ed. Eudeba. Bs. As., 1986.
JAMSA, Keith: Aprenda C++ paso a paso. Ed. Computec, Mxico, 1997.
GARCIA, Jos-BADELL: Turbo C++3: Programacin y manejo de archivos. Addison
Wesley Iberoamericana Wilmington, Delaware, E.U.A., 1994.
MURRAY III, William y PAPPAS, Chris: Manual de Borland C++. Ed. Mc GrawHill.
Espaa, 1998.
VILLALOBOS, Jorge A. : Diseo y manejo de estructuras de datos en C. Ed. Mc Graw-
Hill. Bogot, 1996.
BOWMAN, Charles : Algoritmos y Estructuras de Datos: Aproximacin en C. Oxford.
Mxico D.F., 1999.
ANTONAKOS, James y MANSFIELD Jr., Kenneth: Programacin Estructurada en C.
Prentice-Hall. Madrid, 1997.
TENENBAUM, Aaron-LANGSAM, Yedidyah y AUGENSTEIN, Moshe: Estructuras de
Datos en C.
JOYANES AGUILAR, Luis y ZAHONERO MARTINEZ, Ignacio: Programacin en C:
Metodologa, estructura y objetos. McGraw-Hill. Mxico D.F., 2001.
MATA-TOLEDO, Ramn y CUSHMAN, Pauline: Introduccin a la Programacin.
McGraw-Hill/Schaum. Mxico D.F., 1999.