Created
June 8, 2020 19:10
-
-
Save parzibyte/70c0bb544b1152d859bb0fc840cfe780 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
____ _____ _ _ _ | |
| _ \ | __ \ (_) | | | | |
| |_) |_ _ | |__) |_ _ _ __ _____| |__ _ _| |_ ___ | |
| _ <| | | | | ___/ _` | '__|_ / | '_ \| | | | __/ _ \ | |
| |_) | |_| | | | | (_| | | / /| | |_) | |_| | || __/ | |
|____/ \__, | |_| \__,_|_| /___|_|_.__/ \__, |\__\___| | |
__/ | __/ | | |
|___/ |___/ | |
Blog: https://parzibyte.me/blog | |
Ayuda: https://parzibyte.me/blog/contrataciones-ayuda/ | |
Contacto: https://parzibyte.me/blog/contacto/ | |
Copyright (c) 2020 Luis Cabrera Benito | |
Licenciado bajo la licencia MIT | |
El texto de arriba debe ser incluido en cualquier redistribución | |
Errores esperados, documentación y esas cosas... | |
- No puede haber más filas que letras del abecedario, porque solo se imprime | |
hasta la Z | |
- No puede haber más de 9 columnas porque ya no se imprimiría bien, y porque | |
ya no se convertiría correctamente el entero a cadena para mostrar las minas | |
cercanas | |
- Al colocar las minas se puede colocar una mina sobre otra mina, ya que no se | |
verifica lo que hay antes de colocarla. Por lo tanto, en ocasiones se podrían | |
poner menos minas de las que se configuran | |
*/ | |
#include <assert.h> // assert | |
#include <ctype.h> // toupper | |
#include <stdio.h> // printf, scanf | |
#include <stdlib.h> // rand | |
#include <unistd.h> // getpid | |
// Cosas que no deberías modificar si no sabes lo que haces | |
#define ERROR_MINA_ENCONTRADA 1 | |
#define ERROR_ESPACIO_YA_DESCUBIERTO 2 | |
#define ERROR_NINGUNO 3 | |
// Cosas que puedes modificar ;) | |
#define COLUMNAS 5 | |
#define FILAS 5 | |
#define ESPACIO_SIN_DESCUBRIR '.' | |
#define ESPACIO_DESCUBIERTO ' ' | |
#define MINA '*' | |
#define CANTIDAD_MINAS \ | |
5 // ¿cuántas minas colocar en el tablero de manera aleatoria? va a fallar si | |
// hay menos espacio que el número de minas | |
#define DEBUG 0 // Si lo pones en 1, se van a desocultar las minas | |
// Devuelve el número de minas que hay cercanas en determinada coordenada | |
int obtenerMinasCercanas(int fila, int columna, char tablero[FILAS][COLUMNAS]) { | |
int conteo = 0, filaInicio, filaFin, columnaInicio, columnaFin; | |
if (fila <= 0) { | |
filaInicio = 0; | |
} else { | |
filaInicio = fila - 1; | |
} | |
if (fila + 1 >= FILAS) { | |
filaFin = FILAS - 1; | |
} else { | |
filaFin = fila + 1; | |
} | |
if (columna <= 0) { | |
columnaInicio = 0; | |
} else { | |
columnaInicio = columna - 1; | |
} | |
if (columna + 1 >= COLUMNAS) { | |
columnaFin = COLUMNAS - 1; | |
} else { | |
columnaFin = columna + 1; | |
} | |
int m; | |
for (m = filaInicio; m <= filaFin; m++) { | |
int l; | |
for (l = columnaInicio; l <= columnaFin; l++) { | |
if (tablero[m][l] == MINA) { | |
conteo++; | |
} | |
} | |
} | |
return conteo; | |
} | |
// Devuelve un número aleatorio entre minimo y maximo, incluyendo a minimo y | |
// maximo | |
// https://parzibyte.me/blog/2019/03/21/obtener-numeros-aleatorios-c/ | |
int aleatorioEnRango(int minimo, int maximo) { | |
return minimo + rand() / (RAND_MAX / (maximo - minimo + 1) + 1); | |
} | |
// Rellena el tablero de espacios sin descubrir | |
void iniciarTablero(char tablero[FILAS][COLUMNAS]) { | |
int l; | |
for (l = 0; l < FILAS; l++) { | |
int m; | |
for (m = 0; m < COLUMNAS; m++) { | |
tablero[l][m] = ESPACIO_SIN_DESCUBRIR; | |
} | |
} | |
} | |
// Coloca una mina en las coordenadas indicadas | |
void colocarMina(int fila, int columna, char tablero[FILAS][COLUMNAS]) { | |
tablero[fila][columna] = MINA; | |
} | |
// Coloca minas de manera aleatoria. El número depende de CANTIDAD_MINAS | |
void colocarMinasAleatoriamente(char tablero[FILAS][COLUMNAS]) { | |
int l; | |
for (l = 0; l < CANTIDAD_MINAS; l++) { | |
int fila = aleatorioEnRango(0, FILAS - 1); | |
int columna = aleatorioEnRango(0, COLUMNAS - 1); | |
colocarMina(fila, columna, tablero); | |
} | |
} | |
void imprimirSeparadorEncabezado() { | |
int m; | |
for (m = 0; m <= COLUMNAS; m++) { | |
printf("----"); | |
if (m + 2 == COLUMNAS) { | |
printf("-"); | |
} | |
} | |
printf("\n"); | |
} | |
void imprimirSeparadorFilas() { | |
int m; | |
for (m = 0; m <= COLUMNAS; m++) { | |
printf("+---"); | |
if (m == COLUMNAS) { | |
printf("+"); | |
} | |
} | |
printf("\n"); | |
} | |
void imprimirEncabezado() { | |
imprimirSeparadorEncabezado(); | |
printf("| "); | |
int l; | |
for (l = 0; l < COLUMNAS; l++) { | |
printf("| %d ", l + 1); | |
if (l + 1 == COLUMNAS) { | |
printf("|"); | |
} | |
} | |
printf("\n"); | |
} | |
// Convierte un int a un char. Por ejemplo 0 a '0' | |
char enteroACaracter(int numero) { | |
return numero + '0'; | |
} | |
void imprimirTablero(char tablero[FILAS][COLUMNAS], int deberiaMostrarMinas) { | |
imprimirEncabezado(); | |
imprimirSeparadorEncabezado(); | |
char letra = 'A'; | |
int l; | |
for (l = 0; l < FILAS; l++) { | |
int m; | |
// Imprimir la letra de la fila | |
printf("| %c ", letra); | |
letra++; | |
for (m = 0; m < COLUMNAS; m++) { | |
// No le vamos a mostrar al usuario si hay una mina... | |
char verdaderaLetra = ESPACIO_SIN_DESCUBRIR; | |
char letraActual = tablero[l][m]; | |
if (letraActual == MINA) { | |
verdaderaLetra = ESPACIO_SIN_DESCUBRIR; | |
} else if (letraActual == ESPACIO_DESCUBIERTO) { | |
// Si ya lo abrió, entonces mostramos las minas cercanas | |
int minasCercanas = obtenerMinasCercanas(l, m, tablero); | |
verdaderaLetra = enteroACaracter(minasCercanas); | |
} | |
// Si DEBUG está en 1, o debería mostrar las minas (porque perdió o ganó) | |
// mostramos la mina original | |
if (letraActual == MINA && (DEBUG || deberiaMostrarMinas)) { | |
verdaderaLetra = MINA; | |
} | |
printf("| %c ", verdaderaLetra); | |
if (m + 1 == COLUMNAS) { | |
printf("|"); | |
} | |
} | |
printf("\n"); | |
imprimirSeparadorFilas(); | |
} | |
} | |
// Recibe la fila, columna y tablero. La fila y columna deben ser tal y como las | |
// proporciona el usuario. Es decir, la columna debe comenzar en 1 (no en cero | |
// como si fuera un índice) y la fila debe ser una letra | |
int abrirCasilla(char filaLetra, int columna, char tablero[FILAS][COLUMNAS]) { | |
// Convertir a mayúscula | |
filaLetra = toupper(filaLetra); | |
// Restamos 1 porque usamos la columna como índice | |
columna--; | |
// Convertimos la letra a índice | |
int fila = filaLetra - 'A'; | |
assert(columna < COLUMNAS && columna >= 0); | |
assert(fila < FILAS && fila >= 0); | |
if (tablero[fila][columna] == MINA) { | |
return ERROR_MINA_ENCONTRADA; | |
} | |
if (tablero[fila][columna] == ESPACIO_DESCUBIERTO) { | |
return ERROR_ESPACIO_YA_DESCUBIERTO; | |
} | |
// Si no hay error, colocamos el espacio descubierto | |
tablero[fila][columna] = ESPACIO_DESCUBIERTO; | |
return ERROR_NINGUNO; | |
} | |
// Para saber si el usuario ganó | |
int noHayCasillasSinAbrir(char tablero[FILAS][COLUMNAS]) { | |
int l; | |
for (l = 0; l < FILAS; l++) { | |
int m; | |
for (m = 0; m < COLUMNAS; m++) { | |
char actual = tablero[l][m]; | |
if (actual == ESPACIO_SIN_DESCUBRIR) { | |
return 0; | |
} | |
} | |
} | |
return 1; | |
} | |
int main() { | |
printf("** BUSCAMINAS **\nBy Parzibyte\n"); | |
char tablero[FILAS][COLUMNAS]; | |
int deberiaMostrarMinas = 0; | |
// Alimentar rand | |
srand(getpid()); | |
iniciarTablero(tablero); | |
colocarMinasAleatoriamente(tablero); | |
// Ciclo infinito. Se rompe si gana o pierde, y eso se define con | |
// "deberiaMostrarMinas" | |
while (1) { | |
imprimirTablero(tablero, deberiaMostrarMinas); | |
if (deberiaMostrarMinas) { | |
break; | |
} | |
int columna; | |
char fila; | |
printf("Ingresa la fila: "); | |
scanf(" %c", &fila); | |
printf("Ingresa la columna: "); | |
scanf("%d", &columna); | |
int status = abrirCasilla(fila, columna, tablero); | |
if (noHayCasillasSinAbrir(tablero)) { | |
printf("Has ganado\n"); | |
deberiaMostrarMinas = 1; | |
} else if (status == ERROR_ESPACIO_YA_DESCUBIERTO) { | |
printf("Ya has abierto esta casilla\n"); | |
} else if (status == ERROR_MINA_ENCONTRADA) { | |
printf("Has perdido\n"); | |
deberiaMostrarMinas = 1; | |
} | |
} | |
return 0; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment