Busca Minas

BUSCAMINAS
PR
Alumno: Bartolom Molina Menchn

Profesor: Dr.D.David Losada Carril
Asignatura: Programacin I
Prctica: 3
NDICE
Cdigo .................................................................................................................... 2
buscaminas.h ............................................................................................... 2
buscaminas.c ............................................................................................... 3
int Segundos () ................................................................................ 3
void MostrarTablero (int modo) ..................................................... 3
void DestaparAnexas (int pos_x,int pos_y) .................................... 4
void Partida (int modo) ................................................................... 5
void CalcularMinas () ..................................................................... 8
void GenerarMinas () ...................................................................... 8
void ElegirTamano () ...................................................................... 9
void menu () ................................................................................... 10
void intro_1 () ........................................................................ 11
void intro_2 () ................................................................................ 11
void main () .................................................................................... 11
ficheros.c 12
void AnadirEnOrden (struct datos user, int modo) 12
void CargarResultados (int modo) ................................................. 12
void GrabarResultados (int modo) ................................................. 12
void MostrarResultados (int modo) ............................................... 13
void GuardarResultado (int tiempo, int modo) .............................. 13
void IntroducirContrasena (char **contrasena) ............................. 14
void GuardarPartida (int x, int y, int minas, int destapadas,
int banderas, int pos_x,
int pos_y, int seg, int modo_juego,
struct casilla **tablero) ............................... 14
void CargarPartida (int *x, int *y, int *minas, int *destapadas,
int *banderas, int *pos_x,
int *pos_y, int *seg, int *modo_juego,
struct casilla ***tablero) ............................. 15
Instrucciones .......................................................................................................... 17
Compilacin ........................................................................................................... 18
Acerca de Buscaminas Pro .................................................................................... 19
CDIGO
/*
buscaminas.h
declaracin de tipos
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include <string.h>
typedef enum{oculto, /* si la casilla no ha sido destapada */
visible,
/* si la casilla ha sido destapada */
mina,
/* si la casilla est marcada como mina */
dudoso} est;
/* si la casilla est marcada como dudosa */
struct casilla
{
char sel; /* es '>' si el cursor est en la casilla */
int ady; /* nmero de minas adyacentes, 9 si es una mina */
est estado;
};
/*
buscaminas.c
EPS - USP CEU
Ingeniera Informtica
Prctica 3 MPI: Buscaminas
Alumno: Bartolom Molina Menchn
Profesor: Dr. D. David Losada Carril
Curso: 2001/2002
Fecha: 15/4/2002
NOTA: este programa ha sido compilado con Microsoft Visual C++ 6.0 y contiene
funciones que no estn definidas en el ANSI C, por lo tanto es posible que
no sea compatible con muchos compiladores
*/
#include "buscaminas.h"
struct casilla **tablero;
int x,
/* tabla dinmica de 2 dimensiones */
/* nmero de columnas del tablero */

y,
/* nmero de filas del tablero */
minas,
/* nmero de minas */
destapadas = 0,
/* nmero de casillas destapadas */
banderas = 0,
/* banderas (posibles minas) puestas */
pos_x = 0, /* componente x del cursor */
pos_y = 0, /* componente y del cursor */
seg = 1, /* tiempo acumulado en segundos */
modo_juego;
/* 1.- principiante 2.- intermedio 3.- experto 0.- personalizado */
/* prototipos de funciones */
void GenerarMinas ();
void menu ();
void main ();
/* protoripos de funciones definidas en ficheros.c */
void GuardarResultado (int, int);
void GuardarPartida (int, int, int, int, int, int, int, int, int, struct casilla **);
void CargarPartida (int *, int *, int *, int *, int *, int *, int *, int *, int *, struct casilla ***);
void MostrarResultados (int);
/* devuelve los segundos del reloj */
int Segundos ()
{
struct tm *tiempo;
time_t t;
time (&t);
tiempo = localtime(&t);
return tiempo->tm_sec;
}
/* muestra el tablero del juego por pantalla segn el modo:
0: modo normal
1: todas las casillas visibles (cuando se pierde)
2: todas las casillas tapadas (cuando el juego est en pausa) */
void MostrarTablero (int modo)
{
int ancho,
alto;
printf ("PR%c\n\n ",1);
/* imprime el eje de coordenadas x */
for (ancho=0; ancho<x; ancho++)
printf ("%3d",ancho);
printf ("\n ");
/* imprime lneas debajo del eje de coordenadas x */
for (ancho=0; ancho<x*3; ancho++)
printf ("%c",95);
/* imprime la primera lnea vertical del eje de coordenadas y */
printf ("\n %c\n",179);

/* imprime el tablero por filas*/
for (alto=0; alto<y; alto++)
{
/* imprime el nmero de fila y una raya vertical al primcipio de cada fila */
printf ("%2d%c",alto,179);
/* imprime todas las casillas de la lnea */
{
/* si la casilla est oculta y el modo es 0 o el modo es 2 se imprime el
cursor (si tiene) y un cuadrado negro */
if (((tablero[ancho][alto].estado == oculto)&&(!modo)) || (modo == 2))
{
printf (" %c%c",tablero[ancho][alto].sel,219);
continue;
}
/* si la casilla est visible y el modo es 0 o el modo es 1 se imprime el
cursor (si tiene) y un cuadrado negro y lo que corresponda */
if (((tablero[ancho][alto].estado == visible)&&(!modo)) || (modo == 1))
{
/* una mina */
if (tablero[ancho][alto].ady == 9)
{
continue;
}
/* un cuadro gris (si la casilla tiene 0 minas adyacentes) */
if (tablero[ancho][alto].ady == 0)
{
continue;
}
/* el nmero de minas adyacentes */
printf (" %c%d",tablero[ancho][alto].sel,tablero[ancho][alto].ady);
continue;
}
/* si la casilla est marcada como mina se imprime una bandera */
if (tablero[ancho][alto].estado == mina)
{
continue;
}
/* si la casilla est marcada como dudosa se imprime una interrogacin */
if (tablero[ancho][alto].estado == dudoso)
{
printf (" %c?",tablero[ancho][alto].sel);
continue;
}
}
/* se imprimen barras verticales entre lnea y lnea */
if (alto != y-1)
printf ("\n %c\n",179);
}
printf ("\n\n");
}
/* destapa todas las casillas anexas de una que no tiene minas adyacentes */
void DestaparAnexas (int pos_x,int pos_y)
{
int
i,
j;
/* destapa la casilla */
tablero[pos_x][pos_y].estado = visible;
for (i=-1; i<2; i++)
for (j=-1; j<2; j++)
if (((pos_x+i>=0)&&(pos_x+i<x))&&((pos_y+j>=0)&&(pos_y+j<y)))
if (tablero[pos_x+i][pos_y+j].estado != visible)
{
/* si la casilla estaba marcada como mina, se quita la bandera */
if (tablero[pos_x+i][pos_y+j].estado == mina)
banderas--;
/* si la casilla tampoco tiene adyacentes se hace una llamada
recursiva */
if (tablero[pos_x+i][pos_y+j].ady == 0)
DestaparAnexas (pos_x+i,pos_y+j);
tablero[pos_x+i][pos_y+j].estado = visible;
destapadas++;
}
}
/* gestiona la partida segun el modo:
0: modo normal
1: cuando se pierde
2: cuando el juego est en pausa */
void Partida (int modo)
{
int tiempo = Segundos (); /* decide cuando hay que cambiar los segundos */
system ("cls");
MostrarTablero (modo);
/* si se han destapado todas las casillas sin minas (cuando se gana) */
if (destapadas == (x*y)-minas)
{
printf ("\nHas ganado!!!\n");
printf ("\n1.. Volver a jugar");
printf ("\n2.. Volver al menu");
/* no se guardan los mejores de modos personalizados */
if (modo_juego)
printf ("\n3.. Guardar resultado");
/* se restauran los datos de la partida */
pos_x = pos_y = 0;
tiempo = seg;
seg = 1;
banderas = 0;
destapadas = 0;
switch (getch ())
{
case '1': /* volver a jugar en el mismo modo */
GenerarMinas ();
case '2':
/* volver al men principal */

menu ();
case '3':
/* guardar el resultado */
/* no se guardan los mejores de modos personalizados */
if (modo_juego)
GuardarResultado (tiempo, modo_juego);
default:
Partida (0);
}
}
/* si se ha destapado alguna casilla con mina (se ha perdido) */
if (modo == 1)
{
printf ("\nHas perdido\n");
printf ("\n1.. Menu principal");
printf ("\n2.. Volver a intentarlo");
/* se restauran los datos de la partida */
pos_x = pos_y = 0;
seg = 1;
banderas = 0;
destapadas = 0;
switch (getch ())
{
case '1': /* volver al men principal */
menu ();
case '2':
/* volver a jugar en el mismo modo */

GenerarMinas ();
default:
Partida (1);
}
}
/* si el juego est en pausa */
if (modo == 2)
{
printf ("\nPulsa una tecla para continuar la partida");
getch ();
Partida (0);
}
printf ("\nEnter:destapar m:mina d:dudosa o:desmarcar p:pausa g:guardar r:retirarse\n");
/* imprime el nmero de banderas restantes y el tiempo acumulado */
printf ("banderas restantes: %d\n", minas-banderas);
printf ("segundos:%4d",seg);
/* mientras no se pulse una tecla, seg se incrementa cada segundo */
while (!kbhit ())
{
if (tiempo != Segundos ())
{
printf ("\rsegundos:%4d",seg++);
tiempo = Segundos ();
}
}
switch (tolower (getch ()))
{
case 224: /* si se ha pulsado una tecla del cursor */
switch (getch ())
{
case 72: /* flecha arriba */
if (pos_y-1 >= 0)
{
tablero[pos_x][pos_y].sel = ' ';
pos_y = pos_y-1;
tablero[pos_x][pos_y].sel = '>';
}
Partida (0);
case 80:
/* flecha abajo */
if (pos_y+1 < y)
{
pos_y = pos_y+1;
}
Partida (0);
case 75:
/* flecha izquierda */
if (pos_x-1 >= 0)
{
pos_x = pos_x-1;
}
Partida (0);
case 77:
/* flecha derecha */
if (pos_x+1 < x)
{
pos_x = pos_x+1;
}
Partida (0);
case 13:
/* si se pulsa enter (destapar) */

/* si la casilla destapada es una mina, se pierde */
if (tablero[pos_x][pos_y].ady == 9)
Partida (1);
/* si no es una mina */
else
/* si no tiene minas adyacentes */
if (tablero[pos_x][pos_y].ady == 0)
{
/* si haba una bandera, se quita */
if (tablero[pos_x][pos_y].estado == mina)
banderas--;
/* se destapan las casillas anexas */
DestaparAnexas (pos_x, pos_y);
}
/* si tiene minas adyacentes */
else
{
banderas--;
/* se marca como casilla visible */
tablero[pos_x][pos_y].estado = visible;
}
destapadas++;
Partida (0);
case 'm':
/* si se pulsa 'm' (marcar como mina) */

if ((tablero[pos_x][pos_y].estado != visible)&&(tablero[pos_x][pos_y].estado != mina))
{
tablero[pos_x][pos_y].estado = mina;
banderas++;
}
Partida (0);
case 'd':
/* si se pulsa 'd' (marcar como dudosa) */

if (tablero[pos_x][pos_y].estado != visible)
{
banderas--;
tablero[pos_x][pos_y].estado = dudoso;
}
Partida (0);
case 'o':
/* si se pulsa 'o' (desmarcar casilla) */

if (tablero[pos_x][pos_y].estado != visible)
{
banderas--;
tablero[pos_x][pos_y].estado = oculto;
}
Partida (0);
case 'p':
/* si se pulsa 'p' (parar el juego) */

Partida (2);
case 'g':
/* si se pulsa 'g' (guardar el juego) */

GuardarPartida (x, y, minas, destapadas, banderas, pos_x, pos_y, seg, modo_juego, tablero);
case 'r':
/* si se pulsa 'r' (retirarse y volver al men principal) */

pos_x = pos_y = 0;
seg = 1;
banderas = 0;
destapadas = 0;
menu ();
default:
printf ("\nOpcion incorrecta, pulse enter para elegir una opcion");
getch ();
Partida (0);
}
}
/* calcula de cada casilla las minas que tiene alrededor y guarda el valor en
tablero[ancho][alto].ady; guarda un 9 si la casilla contiene una mina y un 0
si no tiene minas adyacentes */
void CalcularMinas ()
{
int alto,
ancho,
i,
j;
/* recorre las columnas del tablero */
/* recorre las filas del tablero para cada columna */
/* calcula las casillas adyacentes con mina */
for (i=-1; i<2; i++)
for (j=-1; j<2; j++)
if (tablero[ancho][alto].ady != 9)
if
(((ancho+i>=0)&&(ancho+i<x))&&((alto+j>=0)&&(alto+j<y)))
if (tablero[ancho+i][alto+j].ady == 9)
tablero[ancho][alto].ady++;
Partida (0);
}
/* genera las minas de forma aleatoria */
void GenerarMinas ()
{
int ancho,
alto,
minas_aux;
/* se decrementa cuando se inserta una mina */
minas_aux = minas;
/* reserva memoria para el tablero */
tablero = (struct casilla **)malloc(x*sizeof (struct casilla *));
tablero[ancho] = (struct casilla *)malloc(y*sizeof (struct casilla));
/* se inicializa el generador de nmeros aleatorios */
srand(time(NULL));
/* se recorre el tablero */
{
/* si hay o se va a poner una mina en la casilla */
if (((minas_aux)&&(rand()%20 == 0))||(tablero[ancho][alto].ady == 9))
{
if (tablero[ancho][alto].ady != 9)
minas_aux--;
tablero[ancho][alto].ady = 9;
}
/* si la casilla no tiene mina */
else
tablero[ancho][alto].ady = 0;
/* si se ha recorrido toda la tabla y todava no se han colocado todas las
minas, se vuelve a recorrer el tablero */
if ((ancho == x-1)&&(minas_aux))
ancho = -1;
}
/* se quita el cursor de todas las casillas */

{
tablero[ancho][alto].estado = oculto;
tablero[ancho][alto].sel = ' ';
}
/* y se pone en la primera */
tablero[0][0].sel = '>';
CalcularMinas ();
}
/* permite elegir uno de los modos de juego: la anchura de el tablero se guarda en la
variable global x, la altura en y, el nmero de minas en minas y el modo de juego
en modo_juego */
void ElegirTamano ()
{
system ("cls");
printf ("\t\t**** ESCOGER NIVEL ****\n");
printf ("\n1.. Principiante (9x9, 10 minas)");
printf ("\n2.. Intermedio (16x16, 40 minas)");
printf ("\n3.. Experto (25x16, 99 minas)");
printf ("\n4.. Personalizado");
printf ("\n5.. Volver al menu principal");
switch (getch ())
{
case '1': /* modo principiante */
x = 9;
y = 9;
minas = 10;
modo_juego = 1;
GenerarMinas ();
case '2':
/* modo intermedio */
x = 16;
y = 16;
minas = 40;
modo_juego = 2;
GenerarMinas ();
case '3':
/* modo experto */
x = 25;
y = 16;
minas = 99;
modo_juego = 3;
GenerarMinas ();
case '4':
/* modo personalizado */
system ("cls");
modo_juego = 0;
printf ("Introduzca la anchura del tablero (2-25): ");
scanf (" %d",&x);
/* comprueba la anchura del tablero */
if ((x > 25)||(x < 2))
{
printf ("\n\nla anchura del tablero no puede ser mayor de 30 ni menor de 2"
", pulse enter para continuar");
getch ();
ElegirTamano ();
}
printf ("\nIntroduzca la altura del tablero (2-22): ");
scanf (" %d",&y);
/* comprueba la altura del tablero */
if ((y > 22)||(y < 2))
{
printf ("\n\nla altura del tablero no puede ser mayor de 22 ni menor de 2"
", pulse enter para continuar");
getch ();
ElegirTamano ();
}
printf ("\nIntroduzca el numero de minas (1-(alto*ancho-1)): ");

scanf (" %d",&minas);
/* comprueba el nmero de minas */
if ((minas >= x*y)||(minas < 1))
{
/* comprueba si se quieren introducir mas minas que casillas */
if (minas >= x*y)
printf ("\n\nVamos a meter todas esas minas ahi???");
else
printf ("\n\nNo seria un poco facil??? Anda, mete mas minas");
printf (", pulse enter para continuar");
getch ();
ElegirTamano ();
}
GenerarMinas ();
case '5':
/* volver al men */
menu ();
default:
getch ();
ElegirTamano ();
}
}
/* imprime un men por pantalla con las opciones del juego */
void menu ()
{
system ("cls");
printf ("\t\t**** BUSCAMINAS PRO ****");
printf ("\n\nSeleccione una opcion:\n");
printf ("\n1.. Nueva partida");
printf ("\n2.. Cargar Partida");
printf ("\n3.. Los mejores modo principiante");
printf ("\n4.. Los mejores modo intermedio");
printf ("\n5.. Los mejores entre los mejores (modo experto)");
printf ("\n6.. Mostrar creditos");
printf ("\n0.. Salir");
switch (getch ())
{
case '1': /* nueva partida */
system ("cls");
ElegirTamano ();
break;
case '2':
/* cargar partida */
CargarPartida (&x, &y, &minas, &destapadas, &banderas, &pos_x, &pos_y, &seg, &modo_juego, &tablero);
case '3':
/* top principiantes */
MostrarResultados (1);
case '4':
/* top intermedio */
case '5':
/* top expertos */
case '6':
/* mostrar crditos */
system ("cls");
main ();
case '0':
/* salir del juego */

free (tablero);
exit (0);
default:
getch ();
menu ();
}
}
10
/* muestra los crditos del programa */

void intro_1 ()
{
printf("
!\n");
printf("
!__. ; '_\n");
printf("
!____. ._, `!__\n");
printf(" ^; ,____\" ;__` ;___
** UNIVERSIDAD SAN PABLO - CEU **\n");
printf(" ,__ _____ .___,`___,\n");
printf(" \"__\" `;___\" ;__`,_;^\n");
printf(" ___. ____.._, \"\n");
printf(" __^
___! ; `\"^
Practica 3 MPI. Buscaminas\n");
printf(" ^,
^___ ,___\n");
printf(" `
`___. ;__^\n");
printf("
;__. ,__!\n");
printf("
___. ;!` '
Alumno: Bartolome Molina Menchen\n");
printf("
___. _;___!.\n");
printf("
___. .;____;,
Profesor: Dr. D. David Losada Carril\n");
printf("
___. .,\n");
printf("
___.
Curso: 2001/2002\n");
printf("
___.\n");
printf("
___.\n");
printf("
___.\n");
printf("
___.\n");
printf("
___.\n");
printf("
___.\n");
printf("
___.\n");
printf("
___.\n");
getch();
}
/* muestra los crditos del programa */
void intro_2 ()
{
printf("\n");
printf("
Bartolome Molina\n");
printf("\n");
printf("
MMM\n");
printf("
M
M\n");
printf("
M\n");
printf(" M MM MM M MMM MMM MMMM MM MM MM M MM MM MMMM MMM\n");
printf(" M M M M M M M M M M M M MM M M M MM M M M M M M M\n");
printf(" MM M M M M M M M M MM M M MM M M M M\n");
printf(" M M M MM MM M M M M M M M M M M M MM\n");
printf(" M M M M M M M M M M MMM M M M M M M M M M MM MMM M M\n");
printf(" MMMM MM MMMMM MMMM MM MM M M MM MM M MM MM MMMMM\n");
printf("\n");
printf("\n");
printf("
M MM MM MM MMM\n");
printf("
MMMM MM M M M M\n");
printf("
M M MM M M\n");
printf("
M M M M M\n");
printf("
M M M M M\n");
printf("
MMMM M MMM\n");
printf("
M\n");
printf("
M\n");
printf("
M\n");
getch();
}
void main ()
{
intro_1 ();
system ("cls");
intro_2 ();
menu ();
}
11
/*
ficheros.c
contiene las funciones relacionadas con el manejo de ficheros del juego
*/
#include "buscaminas.h"
/* estructura que contiene los datos de un usuario ganador */
struct datos
{
char nombre[100];
int tiempo;
}usuario [10];
/* protoripos de funciones definidas en buscaminas.c */
void menu ();
void Partida (int);
/* introduce un usuario en su puesto si su tiempo es de los 10 mejores */
void AnadirEnOrden (struct datos user, int modo)
{
struct datos usr_aux;
int i;
for (i=0; i<10; i++)
{
if (user.tiempo < usuario[i].tiempo)
{
usr_aux = usuario[i];
usuario[i] = user;
AnadirEnOrden (usr_aux, modo);
break;
}
/* si todava no hay 10 mejores, el usuario se mete entre los mejores */
if (usuario[i].tiempo == 0)
{
usuario[i] = user;
break;
}
}
}
/* carga el array "resultados" (10 mejores) con los datos de un fichero de texto */
void CargarResultados (int modo)
{
int i = 0;
FILE *resultados;
if (modo == 1)
/* modo principiante */
resultados = fopen ("principiante.top","a+");
if (modo == 2)
resultados = fopen ("intermedio.top","a+");
if (modo ==3)
/* modo experto */
resultados = fopen ("experto.top","a+");
while (!feof (resultados))
{
fread (&usuario[i], sizeof (struct datos), 1, resultados);
i++;
}
fclose (resultados);
}
/* graba el array "resultados" (10 mejores) en un fichero de texto */
void GrabarResultados (int modo)
{
int i;
FILE *resultados;
if (modo == 1)
resultados = fopen ("principiante.top","w");
12
if (modo == 2)
resultados = fopen ("intermedio.top","w");
if (modo ==3)
/* modo experto */
resultados = fopen ("experto.top","w");
for (i=0; i<10,usuario[i].tiempo; i++)
fwrite (&usuario[i], sizeof (struct datos), 1, resultados);
}
/* lee los mejores resultados de un fichero y los imprime por pantalla */
void MostrarResultados (int modo)
{
int posicion = 1;
/* posicin en el ranking */
struct datos user;
/* datos del usuario */
FILE *resultados;
system ("cls");
if (modo == 1)
{
resultados = fopen ("principiante.top","r");
printf ("\t**** Los mejores principiantes ****\n\n");
}
if (modo == 2)
{
resultados = fopen ("intermedio.top","r");
printf ("\t**** Los mejores intermedios ****\n\n");
}
if (modo ==3)
/* modo experto */
{
resultados = fopen ("experto.top","r");
printf ("\t**** Los mejores entre los mejores ****\n\n");
}
/* si no ha podido abrir el archivo es que todava no se ha creado (todava no
se han guardado resultados en ese modo) */
if (!resultados)
printf ("Todavia no hay ningun resultado introducido");
else
{
while (!feof (resultados))
{
fread (&user, sizeof (struct datos), 1, resultados);
/* si no se ha llegado al final del fichero */
if (user.tiempo)
printf ("%d -> %s : %d segundos\n\n",posicion++,user.nombre,user.tiempo);
user.tiempo = 0;
}
}
printf ("\n\nPulse una tecla para volver al menu");
getch ();
menu ();
}
/* introduce un usuario ganador en el ranking si su tiempo est entre los 10 mejores */
void GuardarResultado (int tiempo, int modo)
{
int i;
struct datos user;
/* datos del usuario ganador */
/* se inicializa el tiempo de los mejores a 0 (eso querr decir que todava no hay
un usuario introducido en esa posicin del ranking */
for (i=0; i<10; i++)
usuario [i].tiempo = 0;
13
system ("cls");
fflush (stdin);
printf ("Introduce tu nombre: ");
gets (user.nombre);
user.tiempo = tiempo;
CargarResultados (modo);
AnadirEnOrden (user, modo);
GrabarResultados (modo);
MostrarResultados (modo);
}
/* permite al usuario introducir un campo de tipo contrasea (con asteriscos) */
void IntroducirContrasena (char **contrasena)
{
int i;
char c;
/* se introducen caracteres en la cadena mientras no se pulse Enter */
for (c=getch (),i=0; c!=13; c=getch (),i++)
{
/* si se pulsa el caracter 8 (borrar caracter) */
if (c == 8)
{
if (i != 0)
{
printf ("%c%c%c",8,' ',8);
i--;
}
i--;
continue;
}
/* reserva memoria segn van introducindose caracteres */
*contrasena = (char *)realloc(*contrasena, (i+1)*sizeof (char));
/* se guarda el caracter en la cadena */
(*contrasena)[i] = c;
/* se imprime un asterisco cada vez que se introduce un caracter */
printf ("*");
}
/* se guarda espacio para introducir el caracter fin de cadena */
*contrasena = (char *)realloc(*contrasena, (i+1)*sizeof (char)+1);
/* se introduce el caracter fin de cadena */
(*contrasena)[i] = 0;
}
/* guarda los datos de una partida para poder recuperarla en el futuro */
void GuardarPartida (int x,
int y,
int minas, /* nmero de minas */
int destapadas,
int banderas,
int pos_x, /* componente x del cursor */
int pos_y, /* componente y del cursor */
int seg, /* tiempo acumulado en segundos */
int modo_juego,
/* 1.- principiante 2.- intermedio 3.- experto
0.- personalizado */
struct casilla **tablero)
{
int i,
j,
tam_contra;
/* tamao de la contrasea asociada al archivo */
char
nombre_archivo[50], /* nombre de la partida a guardar */
*contrasena;
/* contrasea asociada al archivo */
FILE *archivo;
system ("cls");
fflush (stdin);
printf ("Introduzca un nombre de usuario: ");
gets (nombre_archivo);
/* nombre del archivo donde se guardar la partida */
14
printf ("\nIntroduzca una contrasena: ");

/* reserva memoria para un primer caracter */
contrasena = (char *)malloc(1*sizeof (char));
IntroducirContrasena (&contrasena);
archivo = fopen (nombre_archivo,"w");
tam_contra = strlen (contrasena)+1;
/* escribe en el archivo la contrasea asociada */
fwrite (&tam_contra, sizeof (int), 1, archivo);
fwrite (contrasena, sizeof (char), tam_contra, archivo);
/* escribe en el archivo los datos de la partida */
fwrite (&x, sizeof (int), 1, archivo);
fwrite (&y, sizeof (int), 1, archivo);
fwrite (&minas, sizeof (int), 1, archivo);
fwrite (&destapadas, sizeof (int), 1, archivo);
fwrite (&banderas, sizeof (int), 1, archivo);
fwrite (&pos_x, sizeof (int), 1, archivo);
fwrite (&pos_y, sizeof (int), 1, archivo);
fwrite (&seg, sizeof (int), 1, archivo);
fwrite (&modo_juego, sizeof (int), 1, archivo);
/* escribe en el archivo los datos de cada casilla */
for (i=0; i<y; i++)
for (j=0; j<x; j++)
fwrite (&tablero[j][i], sizeof (struct casilla), 1, archivo);
fclose (archivo);
menu ();
}
/* carga los datos de una partida guardada en un fichero */
void CargarPartida (int *x,
int *y,
int *minas,
/* nmero de minas */
int *destapadas,
int *banderas,
int *pos_x,
/* componente x del cursor */
int *pos_y,/* componente y del cursor */
int *seg, /* tiempo acumulado en segundos */
int *modo_juego,
/* 1.- principiante 2.- intermedio 3.- experto
0.- personalizado */
struct casilla ***tablero)
{
int i,
j,
ancho,
tam_contra;
/* tamao de la contrasea asociada al archivo */
char
nombre_archivo[50], /* nombre de la partida a guardar */
*contrasena,
/* contrasea asociada al archivo */
*contrasena_intro; /* contrasea introducida por el usuario */
FILE *archivo;
system ("cls");
printf ("Introduzca un nombre de usuario: ");
gets (nombre_archivo);
/* nombre del archivo desde el que se cargar la partida */
archivo = fopen (nombre_archivo,"r");
/* si no hay ninguna partida guardada con ese nombre vuelve al men */
if (!archivo)
{
printf ("\nUsuario no registrado, pulse una tecla para volver al menu");
getch ();
menu ();
}
printf ("\nIntroduzca una contrasena: ");
/* reserva memoria para un primer caracter */
contrasena_intro = (char *)malloc(1*sizeof (char));
IntroducirContrasena (&contrasena_intro);
fread (&tam_contra, sizeof (int), 1, archivo);
15
/*reserva memoria para introducir la contrasea asociada */

contrasena = (char *)malloc(tam_contra*sizeof (char));
fread (contrasena, sizeof (char), tam_contra, archivo);
/* comprueba si la contrasea introducida es correcta */
if (strcmp(contrasena, contrasena_intro))
{
printf ("\nContrasena no valida, pulse una tecla para volver al menu");
getch ();
menu ();
}
/* carga los datos de la partida */
fread (x, sizeof (int), 1, archivo);
fread (y, sizeof (int), 1, archivo);
fread (minas, sizeof (int), 1, archivo);
fread (destapadas, sizeof (int), 1, archivo);
fread (banderas, sizeof (int), 1, archivo);
fread (pos_x, sizeof (int), 1, archivo);
fread (pos_y, sizeof (int), 1, archivo);
fread (seg, sizeof (int), 1, archivo);
fread (modo_juego, sizeof (int), 1, archivo);
/* reserva memoria en el tablero para todas las casillas */
*tablero = (struct casilla **)malloc(*x*sizeof (struct casilla *));
for (ancho=0; ancho<*x; ancho++)
(*tablero)[ancho] = (struct casilla *)malloc(*y*sizeof (struct casilla));
/* guarda la informacin de cada casilla en su posicin del tablero */
for (i=0; i<*y; i++)
for (j=0; j<*x; j++)
fread (&(*tablero)[j][i], sizeof (struct casilla), 1, archivo);
fclose (archivo);
Partida (0);
}
16
INSTRUCCIONES
El objetivo del juego es destapar todas las casillas que no contengan una mina en el
menor tiempo posible.
Una casilla no destapada se simboliza mediante un cuadrado negro.
Una casilla con una mina se simboliza mediante una mina.
Una casilla marcada como mina se simboliza mediante un rombo (bandera).
Una casilla marcada como dudosa se simboliza mediante un signo de interrogacin ?.
Una casilla destapada y que no tiene minas adyacentes se simboliza mediante un
cuadrado gris.
El nmero que aparece en una casilla cuando se destapa indica el nmero de minas que
hay en las casillas adyacentes.
Si se destapa una casilla con mina, se pierde el juego.
El carcter > es el cursor, que indica la casilla activa sobre la que se va a operar.
Controles:
ENTER
Destapar casilla
m
d
o
p
g
r
Marcar como mina

Marcar como dudosa
Quitar la marca (mina o dudosa)
Pausa
Guardar partida
Retirarse (salir al menu)
17
COMPILACIN
Se recomienda usar el compilador Microsoft Visual C++, ya que hay varias funciones
que no estn definidas en el ANSI C, como rand o system.
Incluir los archivos buscaminas.c (que contiene las funciones generales del juego),
archivos.c (que contiene las funciones relacionadas con el manejo de archivos), y
buscaminas.h (que contiene la declaracin de tipos) en un proyecto.
18
ACERCA DE BUSCAMINAS PRO

Programado en C, en modo texto y sin usar libreras grficas por Bartolom Molina
Menchn, como tercera prctica de metodologa y tecnologa de la programacin I
(Universidad San Pablo CEU) basado en el buscaminas de Microsoft de Robert
Donner y Curt Johnson.
19

Busca Minas

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Busca Minas

Încărcat de

Drepturi de autor:

Formate disponibile

BUSCAMINAS

Alumno: Bartolom Molina Menchn

/* tabla dinmica de 2 dimensiones */

/* nmero de columnas del tablero */

printf ("\n %c\n",179);

/* volver al men principal */

/* volver a jugar en el mismo modo */

/* si se pulsa enter (destapar) */

/* si se pulsa 'm' (marcar como mina) */

/* si se pulsa 'd' (marcar como dudosa) */

/* si se pulsa 'o' (desmarcar casilla) */

/* si se pulsa 'p' (parar el juego) */

/* si se pulsa 'g' (guardar el juego) */

/* si se pulsa 'r' (retirarse y volver al men principal) */

/* se decrementa cuando se inserta una mina */

for (alto=0; alto<y; alto++)

printf ("\nIntroduzca el numero de minas (1-(alto*ancho-1)): ");

/* salir del juego */

/* muestra los crditos del programa */

printf ("\nIntroduzca una contrasena: ");

/reserva memoria para introducir la contrasea asociada /

Marcar como mina

ACERCA DE BUSCAMINAS PRO

S-ar putea să vă placă și