Curso de programación en lenguaje C, diseño de juego buscaminas, ¿cómo hacerlo?
#include
#include
#include
/ ************************************************** * **********************/
/* Convención de estado del mapa*/
/* 0: alrededor 9 No hay minas en ningún cuadrado*/
/* 1~8: Hay 1~8 minas en los 9 cuadrados circundantes*/
/* -1: Los cuadrados con minas*/
/* -2: La cuadrícula abierta con minas*/
/* -3: Límite del mapa*/
/*** * ************************************************* ** ******************/
int Map[12][12]={0} /* Actualmente reproduciendo el mapa de truenos*/
int MapShow[12][12]={0}; /* El lugar seleccionado por el usuario actual, es decir, la cuadrícula "abierta"*/
int nSpaceLeft = 100 ; /* El número de espacios en blanco restantes, 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 result ;
srand(time(NULL)); /* Inicializa el número aleatorio según la hora actual, de modo que la ubicación del trueno sea diferente cada vez que se inicia*/
InitMap() ; /* Inicializa 5 mapas de truenos para que los usuarios elijan */
while(1) /
* Utilice un bucle while para garantizar que el juego solo salga cuando el usuario elija salir*/
{
DrawMainMenu() /* Dibuja el menú principal*/
flusall(); /* Borra todos los buffers de entrada y salida, principalmente borra el buffer de entrada para evitar que la entrada anterior interfiera con getch()*/
ch = getch(); Leer entrada */
switch(ch)
{
case '1': /* El usuario selecciona 1 */
printf ( "\n\tIngrese el número del mapa Lei (1-5):");
while (1) /* Entrada en bucle, si la entrada es incorrecta, siempre solicitará entrada*/
{
flusall();
ch = getch() /* Lee el número del gráfico de truenos ingresado por el usuario*/
if (ch >= '1' && ch <= '5') /* Sólo válido entre 1-5*/
{
LoadMap(ch-'1' ); /* ch -'1', convierte la entrada del usuario en subíndice Leitu (el subíndice comienza desde 0, por lo que es -'1')*/
break /* Si la entrada es correcta, salir del bucle input* /
}
else
{
/* Si la entrada es incorrecta, se le pedirá que re-enter*/
printf("\n\t¡Entrada no válida! Vuelva a ingresar el número del gráfico de truenos (1-5):");
flusall();
}
}
resultado = Play(); /* Empieza a jugar el juego Buscaminas*/
ShowResult(resultado); * Mostrar el resultado del juego*/
break ;
case '2': /* El usuario selecciona 2 */
exit(0); directamente*/
break;
predeterminado: /* Entrada no válida*/
/* No hacer nada y volver a mostrar el menú principal*/
romper;
}
}
devolver 0;
}
void LoadMap(índice int )
{
int i,j;
nSpaceLeft = 90;
for(i=0;i<12;i++ )
for(j=0 ;j<12;j++)
{
Mapa[i][j] = Todos los mapas[index][i] [j]; /* Cambia los 5 mapas de trueno. El que tiene el índice de subíndice se carga en la matriz de mapas*/
MapShow[i][j] = 0 /* Reinicia el juego, así que todo; 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; k<5;k++)
{
/* Inicializa los límites del mapa*/
for(i=0;i<12;i++)
{
/* Las posiciones con subíndices 0 y 11 son ambas "límites". Las ubicaciones no son campos minados y solo se usan dentro del programa*/
AllMaps[k][0][i] = -3
AllMaps[k][11][i; ] = -3;
AllMaps[k][i][0] = -3;
AllMaps[k][i][11] = -3;
p>}
/* Inicializa las posiciones de 10 minas primero*/
for(i=0;i<10;i++)
{
m = rand()%10 + 1; /* Selecciona aleatoriamente una coordenada X*/
n = rand()%10 + 1; Coordenada Y Coordenadas*/
if(AllMaps[k][m][n] == 0) /* Si la ubicación generada aleatoriamente no ha sido organizada para colocar minas antes*/
{
AllMaps[k][m][n] = -1; /* Colocar una mina*/
}
else /* El La posición generada aleatoriamente está en Se colocó una mina antes*/
{
i-- /* Esta posición no es válida, cree una nueva*/
}
}
/* Calcula el número de minas alrededor de cada cuadrícula*/
for(i=1; i<11; i++)
for(j=1; j<11;j++)
{
if(AllMaps[k][i][j] != -1)
{
AllMaps[k][i][j] = 0;
/* Entre las 8 ubicaciones circundantes, si hay una mina, agregue uno*/
/*************************************** ************ *************************/
/* 8 coordenadas posiciones 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] */
/********************* *********** **************************************** ***/
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]++;
si(TodosM
aps[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(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]++;
}
}
}
}
void DrawMap()
{
int i,j;
system("cls"); /* Limpiar pantalla*/
/* Dibujar coordenadas y bordes*/
printf("\n\n\n");
printf(" \t Y ");
for(i=1; i<11; i++) printf("%-02d",i-1);
printf("\n \tX |##################|\n");
/* Cada línea dibuja un campo minado según reglas*/
for(i=1; i<11; i++)
{
printf("\t%-02d|",i-1); Coordenadas*/
for(j=1; j<11; j++)
{
if(MapShow[i][j]) /* if La ubicación ha sido "excavada" por el usuario y se mostrará tal como está*/
{
if (Map[i][j] >= 0) / * No es una mina y se mostrarán los alrededores Número de minas*/
{
printf("%d|",Map[i][j]);
}
/*else if(Mapa[i][j] == 0)
{
printf("0 |");
} */
else if (Map[i][j] == -1) /* Trueno, pantalla* */
{
printf(" *|");
}
else if (Map[i][j] == -2) /* El la mina excavada por el usuario muestra @ */
{
printf("@|");
}
else /* Otras situaciones (no ocurrirán actualmente, para facilitar una futura expansión) */
{
printf(" |");
}
}
else /* Si la posición no ha sido "excavada" por el usuario, se mostrará un espacio*/
{
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");< / p>
printf("\t| 1. Iniciar Buscaminas|\n");
printf("\t| 2. Salir|\n");
printf("\t|##################|\n");
}
int Reproducir( )
{
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* /
/* Ingrese la coordenada X*/
printf("\n\tPor favor ingrese X:");
flusall();
while(1)
{
chX = getch();
if (chX >= '0' && chX <= '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 >= '0' && chY <= '9')
{
Y = chY - '0' + 1;
descanso;
}
else
{
printf("\n\t¡Entrada no válida! Vuelva a ingresar Y:");
flusall();
}
}
if(MapShow[X][ Y ] == 0) /* La entrada es una posición sin abrir*/
{
MapShow[X][Y] = 1 /* Marcar la posición como " "Abierta; " */
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
;i<11;i++)
for(j=1;j<11;j++)
MapShow[i][j]=1 /* El juego termina y el Todas las posiciones están "abiertas" */
/* 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\t Presiona 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\t Presiona cualquier tecla para continuar...",lastX, lastY);
flusall();
getch();
}
}