PROYECTO FINAL DE LABORATORIO DE INFORMATICA
Ricardo Antonio Zambrano Segura.
Docente de Laboratorio de Informática
David Eladio Anacona Ortiz
Juliana Andrea Diaz Cardenas
Estudiante de Ingeniería de Sistemas
Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones
Popayán, Cauca
Febrero
2023
1. Juego del ahorcado, el propósito de este proyecto es realizar una
implementación creativa del mismo haciendo uso de lo aprendido en las
clases de introducción a la informática y su laboratorio.
Introducción
El proyecto contiene todo lo aprendido en laboratorio e introducción; tiene
funciones, estructuras, librerías y arreglos. todas las funciones declaradas que
devuelven algo, guardan el valor, todo lo relacionado con validación y palabra
adivinar está en la librería creada. la función validar entrada es recursiva por lo
que sabemos que ahorramos código y además valida las entradas que ingresa el
usuario y en el inicio del programa todo es muy claro para el usuario. el código
tiene múltiples comentarios para que quizás otros programadores logren
entender.
Entradas
letra: donde se almacena la letra ingresa por el usuario y se crea la
instancia de la estructura palabra.
Salidas
palabra.acierto: si adivino todas la letras entonces adivino la palabra y
se imprime en pantalla “GANASTE”. En caso contrario, “PERDISTE”
Funcionamiento
El proyecto contiene funciones, estructuras, librerías y arreglos. Todas las
funciones guardan el valor y la validación de las palabras se encuentra en una
librería creada, contiene recursividad por lo que ahorramos código. Además,
realiza diferentes procesos de manera simultánea.
Lógica del Programa
Lo primero fue definir la librería creada y con ellos todas las librerías siguientes.
se definen las funciones y la estructura ahorcado. como primer lugar se realizó la
función adivina que pide como parámetro y regresa una estructura ahorcada, se
encarga de escoger una palabra al azar del arreglo diccionario, esta palabra se
asigna a pal de la estructura palabra, además asigna la longitud de la palabra en
el campo le de la estructura palabra. luego en la función fallos, están todos los
casos que se van a dar en las oportunidades que el jugador tenga y en ella está
definido gráficamente el juego. en la estructura genera_pal se encuentra el campo
progreso que es donde se guarda el avance que lleva el jugador y lo representa de
manera visual mediante guiones bajos. en la función existió necesita como
parámetros la letra ingresada y una estructura ahorcado, se encarga de revisar si
la letra ingresada por el usuario ya fue usada antes y además si fue correcta. en la
función validar, también necesita como parámetro la letra ingresada y una
estructura ahorcado. esta contiene un arreglo que es donde se guarda la posición
de la letra ingresada en la palabra adivinar y con ello un contador. En esta función
también se llama la función existió y si hay una letra usada entonces regresara
como el campo flag= 2 , luego dentro de la función validar si el campo flag es igual
a 2 , regresa palabra y termina la función. luego si la función existió el campo flag
es igual a 1. luego si la letra escogida es igual a una letra de la palabra elegida,
bandera es igual a 1. código main. se incluye la librería creada y se definen las
funciones en la función main definimos char letra donde se almacena la letra
ingresada, luego se imprimen las instrucciones del juego, así mismo se imprime
gráficamente el inicio del juego. se llama a la función adivina para escoger la
palabra aleatoria y luego la función genera_pal para generar el formato del campo
progreso.
PROYECTO
FUENTES main.c
#include <stdlib.h>
#include <stdio.h>
#include "ahorcado.h"
//High intensty text
#define HBLK "\e[0;90m"
#define HRED "\e[0;91m"
#define HGRN "\e[0;92m"
#define HYEL "\e[0;93m"
#define HBLU "\e[0;94m"
#define HMAG "\e[0;95m"
#define HCYN "\e[0;96m"
#define HWHT "\e[0;97m"
#define reset "\e[0m"
void instrucciones(void);
char val_entrada(void);
int main(int argc, char **agrs)
{
char letra = '\0';
struct ahorcado palabra = {0};
instrucciones();
fallos(0);
palabra = adivina(palabra);
palabra = genera_pal(palabra);
while (palabra.intento < 8)
{
letra = val_entrada();
palabra = validar(letra, palabra);
if (palabra.flag == 2)
{ //entra aqui si el usuario ingrerso una letra que ya
uso antes y fue correcta
palabra.flag = 1;
continue;
}
fallos(palabra.intento); //Imprime el monito
printf("%s \n", palabra.progreso); //Imprime el
progreso
if (palabra.acierto == palabra.len)
{ //Si atino todas las palbras entonces acerto la
palabra y gano
printf(HGRN);
puts("GANASTE");
printf(reset);
system("pause");
exit(0);
}
}; //si sale del while se hizo el mono completo y perdio
printf(HRED);
puts("Perdiste");
printf(reset);
system("pause");
exit(0);
return 0;
}
void instrucciones()
{
printf(HBLU);
puts("AHORCADO PARA FISICOS");
printf(HCYN);
puts("--BIENVENIDOS--");
printf(HYEL);
puts("Pista:cada palabra pertenece al curso de Mecanica");
printf(HRED);
puts("Introduzca solo letras en minuscula, una a la vez");
printf(HGRN);
puts("Si existiera algun espacio el usuario necesita
introducir un guion bajo");
printf(reset);
}
char val_entrada()
{
char dummy[10] = {'\0'};
printf(HCYN"Dame una letra: ");
scanf("%s", dummy);
printf(reset);
if (dummy[1] == '\0')
return dummy[0];
else
{
puts(HCYN"Recuerda que el programa solo acepta una
letra a la vez"reset);
return val_entrada();
}
}
CABECERAS ahorcado.h
#ifndef __ahorcado
#define __ahorcado
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <ctype.h>
//High intensty text
#define HBLK "\e[0;90m"
#define HRED "\e[0;91m"
#define HGRN "\e[0;92m"
#define HYEL "\e[0;93m"
#define HBLU "\e[0;94m"
#define HMAG "\e[0;95m"
#define HCYN "\e[0;96m"
#define HWHT "\e[0;97m"
#define reset "\e[0m"
#define N 21
struct ahorcado existio(char, struct ahorcado);
struct ahorcado adivina(struct ahorcado);
void fallos(int);
struct ahorcado genera_pal(struct ahorcado);
struct ahorcado validar(char, struct ahorcado);
struct ahorcado
{
int len; //longitud de palabra random
int flag; //para inicializar los caracteres de
progreso
int intento; //intentos incorrectos del usuario
int acierto; //letras correctas ingresadas por el
usuario
int cont_abc; //Contador de letras correctas para
vector abc
char pal[50]; //palabra random
char progreso[100]; // progreso de usuario
char abc[24]; //Vector de letras ya usadas correctas
};
/*----------------------------------------------Llenado de
diccionario----------------------------*/
struct ahorcado adivina(struct ahorcado palabra)
{
const char *diccionario[N] = {"masa", "longitud", "tiempo",
"analisis_dimensional",
"magnitud",
"posicion", "velocidad", "rapidez",
"aceleracion",
"movimiento", "caida_libre", "cantidad_vectorial",
"particula",
"sistemas_coordenados", "vectores",
"movimiento_circular_uniforme", "friccion",
"fuerza", "peso",
"ley_de_newton", "fuerza_gravitacional"};
int n;
srand((unsigned)time(NULL));
n = rand() % 21;
palabra.len = (int)strlen(diccionario[n]);
strcpy(palabra.pal, diccionario[n]);
return palabra;
}
/*----------------------------------------------------------------
---------------------------------*/
void fallos(int n)
{
switch (n)
{
case 0:
printf(HGRN);
puts("¡MUCHA SUERTE!");
printf(reset);
puts(" _ _ ");
puts(" | | ");
puts(" | ");
puts(" | ");
puts(" | ");
puts("_|_ ");
break;
case 1:
puts(HGRN "EXCELENTE HIJO DE NEWTON" reset);
puts(" _ _ ");
puts(" | | ");
puts(" | ");
puts(" | ");
puts(" | ");
puts("_|_ ");
break;
case 2:
puts(" _ _ ");
puts(" | | ");
puts(" | \e[0;91m O \e[0m");
puts(" | ");
puts(" | ");
puts("_|_ ");
break;
case 3:
puts(" _ _ ");
puts(" | | ");
puts(" | \e[0;91m O \e[0m");
puts(" | \e[0;91m / \e[0m ");
puts(" | ");
puts("_|_ ");
break;
case 4:
puts(" _ _ ");
puts(" | | ");
puts(" | \e[0;91m O \e[0m");
puts(" | \e[0;91m /\e[0m\e[0;91m \\ \e[0m");
puts(" | ");
puts("_|_ ");
break;
case 5:
puts(" _ _ ");
puts(" | | ");
puts(" | \e[0;91m O \e[0m");
puts(" | \e[0;91m /\e[0m\e[0;91m \\ \e[0m");
puts(" | \e[0;91m | \e[0m");
puts("_|_ ");
break;
case 6:
puts(" _ _ ");
puts(" | | ");
puts(" | \e[0;91m O \e[0m");
puts(" | \e[0;91m /\e[0m\e[0;91m \\ \e[0m");
puts(" | \e[0;91m | \e[0m");
puts("_|_\e[0;91m / \e[0m");
break;
case 7:
puts(" _ _ ");
puts(" | | ");
puts(" | \e[0;91m O \e[0m");
puts(" | \e[0;91m /\e[0m\e[0;91m \\ \e[0m");
puts(" | \e[0;91m | \e[0m");
puts("_|_\e[0;91m /\e[0m\e[0;91m \\ \e[0m");
break;
default:
puts("¡ADIOS!");
}
}
/*-------------------------------------- genera un arreglo de _
que pertence a cada letra de la palabra asignada en adivina-------
------------------------*/
struct ahorcado genera_pal(struct ahorcado palabra)
{
int n = 0;
int i = palabra.len;
palabra.intento = 1;
for (n = 0; n < i * 2; n += 2)
{
palabra.progreso[n] = '_';
palabra.progreso[n + 1] = ' ';
}
palabra.progreso[i * 2] = '\0';
printf("%s \n", palabra.progreso); //Imprime el progreso
return palabra;
}
/*----------------------------------------------------------------
------------------------------------------------------------------
-------------------------*/
/*-----Revisa si la letra ingresada por el usuario ya se uso y si
es ocrrecta----------------------------------*/
struct ahorcado existio(char letra, struct ahorcado palabra)
{
int j = 0;
for (j = 0; j < palabra.cont_abc; j++) //En este for ve si
la letra ingresada ya fue usada anteriormente
{
if (palabra.abc[j] == letra)
{ //Aqui comprueba si la letra se ha usado
anteriormente
printf(HCYN "Ya usaste la letra: \e[0;91m%c \n"
reset, letra);
palabra.flag = 2;
return palabra;
}
}
return palabra;
}
/*----------------------------------------------------------------
-----------------------------------------------*/
struct ahorcado validar(char letra, struct ahorcado palabra)
{
int i = palabra.len;
int n = 0;
int bandera = 0;
int v[20] = {0}; //Guarda posicion de la letra en la pabra
int cont_v = 0; //Contador de v
palabra = existio(letra, palabra); //revisa si la letra
existio
if (palabra.flag == 2)
return palabra;
//Relaciona la estructura palabra con el campo flag =2
for (n = 0; n < i; n++) //recorre las casillas de la palabra
{
if (palabra.pal[n] == letra) //Revisa si la letra
ingresada es igual a alguna letra de la palabra
{
bandera = 1;
//registra si fallaste o estas en lo correcto
palabra.abc[palabra.cont_abc] = letra; //almacena
la letra nueva y ver si existe en alguna parte
palabra.acierto++;
//Guarda cuantas veces acertaste
palabra.flag = 1;
//Estado del sistema
v[cont_v] = n * 2;
//Almacena la casilla donde fue encontrada la letra
cont_v++;
//Evita que se sobreescriban las letras
}
}
//Verifica si es correcto o no
if (bandera == 0)
{
puts(HRED " NEWTON ESTARIA DECEPCIONADO DE TI " reset);
palabra.intento++; //Muestra parte del ahorcado
}
else
{
puts(HGRN "MUY BIEN" reset);
palabra.cont_abc++;
for (n = 0; n < cont_v; n++)
{
palabra.progreso[v[n]] = letra;
}
}
return palabra;
}
#endif
EN EJECUCIÓN
