Curso de programación en lenguaje C, diseño de juego buscaminas, ¿cómo hacerlo?
#include lt;stdlib.hgt;
#include lt;time.hgt;
#include lt;conio.hgt;
/************************************************ ***********************/
/* Convención de estado del mapa*/
/* 0 : No hay minas en las 9 cuadrículas circundantes*/
/* 1~8: Hay 1~8 minas en las 9 cuadrículas circundantes*/
/* -1: Hay minas Grid*/
/* -2: La grilla descubierta con minas*/
/* -3: Borde del mapa*/
/* ************************************************** * *********************/
int Map[12][12]={0} /* El mapa de la mina actual es jugado */
int MapShow[12][12]={0} /* El lugar seleccionado por el usuario actual, es decir, la cuadrícula "abierta" */
int nSpaceLeft = 100; /* El número restante de espacios en blanco, si es 0, ¡la tarea fue exitosa! */
int lastX, lastY; /* Cuando ocurre una falla, registra la ubicación donde se excavó la mina*/
int AllMaps[5][12][12]={ 0}; /* Cinco mapas de minas para que los usuarios elijan */
/* Muestra el campo minado (se vuelve a mostrar después de cada operación del usuario) */
void DrawMap();
/* Inicializa el campo minado*/
void InitMap();
/* Cuando comienza el juego, carga un mapa de mina seleccionado por el usuario*/
void LoadMap(int index);
/* Juega al juego del buscaminas*/
int Play();
/* Dibuja el mapa principal menu */
void DrawMainMenu();
/* Mostrar el resultado*/
void ShowResult(int result);
/* Función principal*/
int main(int argc, char* argv[])
{
char ch;
int resultado;
srand(tiempo(NULL));
Inicializa el número aleatorio según la hora actual, para que la ubicación del trueno sea diferente cada vez que se inicia*/
InitMap() /* Inicializa 5 mapas de truenos para que el usuario elija*/;
while(1) /* Utilice un bucle while para garantizar que el juego solo salga cuando el usuario elija salir*/
{
DrawMainMenu( ); /* Dibujar el menú principal */
flusall() /* Borrar todos los buffers de entrada y salida, principalmente borrar el buffer de entrada para evitar que la entrada anterior interfiera con getch() */
ch = getch(); /* Leer entrada*/
switch(ch)
{
case '1': /* Usuario selecciona 1 */
printf("\n\tIngrese el número del mapa de truenos (1-5): "
while (1) /* Ingrese el bucle y mantenga); pidiendo información si la entrada es incorrecta */
{
flusall();
ch = getch() /* Lee el número del mapa de la mina. ingresado por el usuario */
if (ch gt; = '1' & ch lt; = '5') /* Solo válido entre 1-5*/
{
LoadMap(ch-'1'); /* ch -'1', convierte la entrada del usuario en un subíndice del mapa Lei (el subíndice comienza desde 0, por lo que es -'1') */
break; /* Si la entrada es correcta, salga del bucle de entrada*/
}
else
{
/* Error de entrada, le solicita que vuelva a ingresar*/
printf("\n\t¡Entrada no válida! Vuelva a ingresar el número del mapa de truenos (1-5): "); /p>
flusall();
}
}
resultado = Jugar() /* Empieza a jugar el juego Buscaminas*/
ShowResult(resultado); /* Mostrar resultados del juego*/
break;
case '2': /* El usuario selecciona 2 */
exit(0); /* Salir directamente* /
break;
default: /* Entrada no válida*/
/* No hacer nada y volver a mostrar el menú principal*/
pausa
}
}
devuelve 0
}
void LoadMap(int index )
{
int i, j
nSpaceLeft = 90; (i=0; ilt; 12; i )
for(j=0;jlt;12;j)
{
Mapa[i][ j] = AllMaps[index][i] [j] /* Carga el que tiene índice entre los 5 mapas de truenos en la matriz de mapas*/
MapShow[i][j] = 0; *
Reinicia el juego, de modo que todas las cuadrículas estén en el estado "sin abrir"*/
}
}
void InitMap()
{
int i, j, k;
int m, n;
/* 5 mapas para inicializar*/
for(k=0; klt; 5; k )
{
/* Inicializa el límite del mapa*/
for(i=0; ilt ;12;i)
{
/* Las posiciones con subíndices 0 y 11 son "límites". Estas posiciones no son campos minados y solo se usan dentro del programa*/
Todos los mapas[k][0][i] = -3
Todos los mapas[k][11][i] = -3
Todos los mapas [; k][i][0] = -3;
Todos los mapas[k][i][11] = -3; Primero inicialice las posiciones de 10 minas*/
for(i=0; ilt; 10; i )
{
m = rand()10 1 ; /* Selecciona aleatoriamente una coordenada X*/
n = rand()10 1 /* Selecciona aleatoriamente una coordenada Y*/
if(AllMaps[k][m ] [n] == 0) /* Si la ubicación generada aleatoriamente no ha sido previamente arreglada para colocar minas*/
{
AllMaps[k][m][n] = - 1; /* Colocar una mina*/
}
else /* La posición generada aleatoriamente ya ha sido colocada con una mina*/
{
p>i--; /* Esta posición no es válida, regenerar una*/
}
}
/* Calcular el entorno de cada cuadrícula Número de minas*/
for(i=1; ilt; 11; i )
for(j=1; jlt; 11; j )
{
if(Todos los mapas[k][i][j] != -1)
{
Todos los mapas[k][i ][j ] = 0;
/* Entre las 8 ubicaciones circundantes, si hay una mina, agrega una*/
/********** ****** ********************************************** ******* *******/
/* 8 posiciones de coordenadas alrededor de las coordenadas [i][j]: */
/* [i- 1][j- 1] [i-1][j] [i-1][j 1] */
/* [i][j-1] [i][j] [ i][j 1 ] */
/* [i 1][j-1] [i 1][j] [i 1][j
1] */
/*************************************** *************************************/
si( Todos los mapas[k][i -1][j-1] == -1)
Todos los mapas[k][i][j] ;
if(Todos los mapas[k] [i-1][ j] == -1)
Todos los mapas[k][i][j] ;
if(Todos los mapas[k][i-1][ j 1] == - 1)
Todos los mapas[k][i][j];
if(Todos los mapas[k][i][j-1] == - 1)
Todos los mapas[k][i][j]
if(Todos los mapas[k][i][j 1] == -1)
Todos los mapas[k] [i][j];
if(Todos los mapas[k][i 1][j-1] == -1)
Todos los mapas[k ][i][j ] ;
if(AllMaps[k][i 1][j] == -1)
AllMaps[k][i][j] ;
if(AllMaps[k][i 1][j 1] == -1)
AllMaps[k][i][j] ；
}
}
}
}
void DrawMap()
{
int i, j;
system("cls"); /* Borrar pantalla*/
/* Dibujar coordenadas y bordes*/
printf("\n\ n\n");
printf("\t Y "
for(i=1; ilt; 11; i ) printf(" -02d",i- 1);
printf("\n\tX |##################|\n");
/* Cada línea dibuja un campo minado según las reglas*/
for(i=1; ilt; 11; i)
{
printf("\t -02d|",i-1 /* Mostrar coordenada X*/
for(j=1; jlt; 11; j)
{
if(MapShow[i][j]) /* Si el usuario "excava" la ubicación, muéstrela tal como está*/
{
if (Map[i] [j] gt; = 0) /* No es mío, muestra el número de minas circundantes*/
{
printf("d |", Mapa[i][j] );
}
/*else if(Mapa[i][j] == 0)
{
printf( "0|");
}*/
else if (Map[i][j] == -1) /* Lei, mostrar* */
{
printf("*|");
}
else if (Map[i][j] == -2) /* Se muestra la mina excavada por el usuario @ */
{
printf("@|");
}
else /* Otras situaciones (no ocurrirán actualmente, para facilitar una futura expansión) */
{
printf(" |");
}
}
else /* Si la ubicación no ha sido " excavado" por el usuario ”, luego se muestran espacios */
{
printf(" |");
}
}
printf("\n");
}
printf("\t |############# ###### |\n");
}
void DrawMainMenu()
{
system("cls ");
printf("\n\n\n\n\n\n");
printf("\t|######### ###### ####|\n");
printf("\t| ¡Por favor seleccione! |\n");
printf("\t | 1. Iniciar Buscaminas| \n");
printf("\t| 2. Salir|\n");
printf("\t|#### ###### #########|\n");
}
int Play()
{
char chX, chY; /* Entrada del usuario*/
int X, Y /* Entrada del usuario convertida a subíndice entero*/
int i, j;
while (1)
{
DrawMap() /* Redibujar el mapa del campo minado*/
/* Introduce la X coordinar*/
printf("\n\tPor favor ingrese X: ");
fluxall()
while(1)
<; p> {chX = getch();
if (chX gt; = '0' amp; chX lt; = '9')
{
X = chX - '0' 1
descanso
}
más
{
printf("\n\t¡Entrada no válida! Vuelva a ingresar X: ");
flusall();
}
}
/* Ingrese la coordenada Y*/
printf("\n\tPor favor ingrese Y: ");
flusall()
while(1)
{
chY
= getch();
if (chY gt; = '0' amp; chY lt; = '9')
{
Y = chY - '0' 1;
descanso;
}
else
{
printf(" \n \tEntrada no válida. Vuelva a ingresar Y: ");
flusall();
}
}
if (MapShow). [X][Y] == 0) /* La entrada es la posición sin abrir*/
{
MapShow[X][Y] = 1; como "abierto" */
if(Map[X][Y] == -1) /* Si la mina es mía*/
{
Map[X][Y] = -2; /* Marcado como -2, lo que indica que se trata de una mina excavada por el usuario*/
for(i=1 ; ilt; 11; i )
for(j=1; jlt; 11; j )
MapShow[i][j]=1; /* El juego ha terminado y se completará automáticamente. Todas las posiciones son " abierto" */
/* Registre las coordenadas de la ubicación donde el usuario cavó minas*/
lastX = X-1;
lastY = Y - 1;
return 0; /* ¡El juego falló! */
}
else /* Si la mina no es mía*/
{
nSpaceLeft-- /* Restante Disminuir el número de espacios en uno*/
if(nSpaceLeft==0) /* Si el número de espacios restantes es 0, significa que el juego fue exitoso*/
{
return 1; /* ¡Juego ganado! */
}
}
}
else /* La entrada es la posición abierta*/
{
printf("\n\tLa posición que ingresó es [d, d]\n\t¡Esta posición ha sido abierta! ¡Vuelva a ingresar!\n\tPresione cualquier tecla para continuar... \n", X-1, Y-1);
flusall();
getch();
}
}
}
void ShowResult( int resultado )
{
DrawMap();
if( resultado == 1) /* Juego exitoso*/
{
printf("\n\t¡Felicitaciones! ¡Has completado la misión del buscaminas!\n\tPresiona cualquier tecla para continuar. ..");
flusall();
getch();
}
else /* El juego falló */
{
printf("\n\t¡Jaja! ¡Cavaste una mina en la ubicación [d, d] y la misión falló!\n\tPresiona cualquier tecla para continuar ..." , últimoX, últimoY);
flusall();
>
getch();
}
}