La Red de Conocimientos Pedagógicos - Currículum vitae - Curso de programación en lenguaje C, diseño de juego buscaminas, ¿cómo hacerlo?

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();

}

}