Juego del ahorcado. Versión 2.

Segunda versión del juego: ahora vamos a obtener las palabras de un fichero de texto.

Abre el fichero y coge la primera palabra, para evitar que se repita siempre, cogeremos cada palabra que ya hayamos utilizado y la colocaremos al final del fichero. Esto vamos a hacerlo a través de un fichero de texto temporal, en el que se colocarán las palabras en el nuevo orden. Después borramos el fichero de texto original y renombramos el nuevo. Este es el aspecto del pequeño fichero que he creado para hacer las pruebas:

Salvo un pequeño cambio en la llamada a la función en Main, sólo se ha tocado la función "Genera_Palabra".

Vamos a ver primero las bibliotecas que se han incluido:

Se ha modificado la llamada a la función "Genera_Palabra", en lugar de devolver ya directamente la palabra, va a devolver una variable del tipo "bool", que nos indicará si ha habido cualquier problema a la hora de abrir los ficheros (por ejemplo si el fichero de palabras no se encuentra en el lugar esperado). Para obtener la palabra que adivinaremos, pasaremos una variable del tipo string como parámetro (se coloca delante el "&" para que se pase la variable por referencia, es decir, los cambios que se realicen dentro de la función, afectarán a la variable de "main" que se le pase de esta forma).

Podemos ver que la llamada ha cambiado y que si el resultado es "false", se muestra un mensaje de error y el programa se detiene.

Vamos ahora a la parte más interesante, la función "Genera_Palabra":

Al trabajar con ficheros hay varias cosas a tener en cuenta, la primera es que es muy común que un fichero no se pueda abrir, ya sea porque no esté donde lo estamos buscando, que otro programa lo esté utilizando y lo tenga bloqueado, etc.... Por eso es importante comprobar primero si se ha abierto correctamente el fichero (función "is_open").
También es muy importante cerrar el fichero cuando terminemos de trabajar con él (función "close").

El resto del código no tiene nada nuevo, aún así, si alguien tiene cualquier duda sobre el código, no dude en comentarlo.

Juego del ahorcado. Parte IV.

Primeras mejoras sobre la versión original. Esta vez, de nuevo he dejado aparcada la generación de palabras, ya que hay que meterse en la gestión de ficheros y prefiero ir paso a paso.

En general las mejoras han sido en la función Main.

Como podemos ver, el primer cambio y más importante es que hemos modificado la variable "palabraResuelta" de estática a dinámica, es decir, en lugar de tener una constante con el máximo y generar un array fijo con ese valor (independientemente del tamaño de la palabra a resolver), ahora se reserva sólo la memoria necesaria para guardar la palabra que vamos a adivinar. Gracias a eso hemos eliminado unas de las inicializaciones (siempre es bueno inicializar todas las palabras). Debido a este cambio también se ha tenido que modificar la función "Pinta_Tablero" y añadirle como parámetro el valor máximo de la palabra original.

También se ha añadido al "Main" algunos ajustes a la hora de mostrar los datos, pero es simplemente estético.

La función "Pinta_Tablero" quedaría así:

Esta vez no voy a poner capturas de las pantallas porque los cambios son mínimos.

La próxima nos metemos con la generación de palabras más currada.


NOTA IMPORTANTE: Siempre que utilicemos memoria dinámica, es de vital importancia que cuando terminemos de usar esas variables, eliminemos la memoria que se ha reservado con ellas (función "delete").

Juego del ahorcado. Parte III.

Ahora vamos a ver el código de la primera versión (muy muy muy mejorable). En las próximas versiones me gustaría optimizar el código y realizar todas las mejoras que se nos ocurran.

 

La función Generar_Palabra:

 

Esta es la primera versión y he preferido hacerlo lo más sencillo posible así que introducimos ya la palabra fija por código.

La función Pinta_Tablero:

Esta función pinta las vidas restantes y la palabra que estamos averiguando, las letras que no hayamos averiguado las coloca como guiones bajos.


La función Procesa_Entrada:

La función para procesar cada letra que introducimos se encarga de ver si esa letra pertenece a la palabra a adivinar. Si no está en la palabra, resta una vida y si aún quedan vidas restantes devuelve "false" (es decir, avisa de que no ha terminado el juego), en cambio si se han terminado las vidas, devuelve "true" indicando que el juego ha terminado. Si la letra está incluida en la palabra y todavía no está averiguada, la sustituye en el array que la almacena y comprueba si ha terminado, si la palabra está completa indica que el juego ha terminado devolviendo "true".


Función main:

En esta primera parte de la función creamos e inicializamos todas las variables. En el caso de la palabra resuelta (donde se irán guardando las letras que vayamos acertando) es un array fijo de tamaño 50 (predefinido en una constante) que inicializamos primero a "1". Después se vuelve a incializar a "0" sólo las posiciones que serán ocupadas por la palabra a adivinar, así sabemos si es un hueco vacío o es una posición que no se debe utilizar (una pista, esto es muy muy mejorable).

En la segunda parte tenemos un bucle do-while que se ejecuta hasta que el jugador decide salir (introduciendo "0") o cuando termina la partida.

Y ahora unos pantallazos de cómo queda el juego (también muy mejorable):

Juego del ahorcado. Parte II.

En este post voy a exponer el primer boceto de la estructura del programa función a función.

Función Genera_Palabra:
Esta función generará una palabra para que el usuario la averigue. Esta función será la que más se modifique según vayamos generando versiones del programa.

Función Pinta_Tablero:
Al ser una aplicación de consola, esta función será la encargada de limpiar la pantalla y pintar el tablero cada vez que la invoquemos.

Función Procesa_Entrada:
Coge la letra que ha seleccionado el usuario y procesa si es una letra válida o no. Si se ha completado la palabra, lo indicará y también notificará cuando el usuario decida dejar de jugar.

Función Main:
Será la función principal del programa e irá llamando al resto de funciones.

Ya con la idea general, se pueden ir desarrollando más en concreto cada una de las funciones.

Cambio de Rumbo

En vista del nuevo cambio de política de Microsoft en cuanto a licencias, voy a cambiar y a recomendar el Visual Studio Community 2015, de hecho, es el que yo estoy utilizando tanto para C++ como para C#/.NET.

Tres en Raya. Parte IV.

Como añadí en el comentario de la parte III de este juego, he buscado cómo añadir un control para que el usuario no pueda introducir un valor incorrecto al pedir un número. He cogido este código de internet  ( http://www.cristalab.com/tutoriales/validacion-de-tipos-de-datos-en-c--c92149l/ ).

Para utilizarlo se puede utilizar como condición que sea un número correcto y si no es así, que repita un bucle para volver a introducir el valor correcto o salir del programa. Exactamente igual que en el "main" cuando preguntamos al usuario si quiere volver a jugar o no.

Juego del ahorcado. Parte I.

Creo que todos conocemos el juego del ahorcado, en el que hay que adivinar la palabra oculta a través de sus letras (como la ruleta de la fortuna, pero más macabro). Vamos diciendo letras, si la palabra o frase contiene esa letra, se nos indica la posición o posiciones en los que se encuentra, si no contiene esa letra, se pierde una "vida" o lo que es lo mismo, se pinta una de las líneas que forman el muñequito del ahorcado, si el muñequito termina de formarse sin acertar la palabra, has perdido.

Como este será seguramente el último ejemplo práctico como aplicación de consola, me gustaría enfocarlo de una forma diferente, más en el diseño que en mostrar el código ya hecho. Vamos a empezar analizando los requisitos:

Para la primera versión, dispondremos de un fichero de texto en el que estarán las palabras que pueden aparecer en el juego, de ahí se seleccionará una palabra y se mostrará en pantalla el contador de vidas (para la primera versión no vamos a pintar muñequito) y la representación de las diferentes letras de la palabra. Se solicitará al usuario que introduzca una letra y se comprobará si ésta está contenida en la palabra, en caso afirmativo, se pintarán todas las coincidentes y en caso negativo, restaremos una "vida". Si el usuario completa la palabra gana y si se terminan sus vidas, pierde. Debe haber una opción para que el usuario pueda dejar de jugar en cualquier momento.

Tenemos una idea clara y concreta de qué nos están pidiendo, ¿pero cómo lo hacemos? Vamos a dividir el problema en partes más sencillas:
   1. Elegir y coger una palabra del fichero.
   2. Mostrar por pantalla el "tablero" de juego.
   3. Procesar cada palabra que introduzca el usuario.
   4. Ofrecer al usuario una opción de salida y de volver a jugar al terminar.

El primer paso, es aprender a abrir el fichero de texto (esto lo aprenderemos a hacer en el próximo post). Una característica de estos ficheros, es que hay que extraer su información línea a línea (en nuestro caso, como tendremos una sóla palabra por línea, será palabra a palabra), es decir, no podemos elegir a qué linea acceder directamente. Aquí podemos ver un ejemplo de un fichero de palabras:

Para escoger una palabra para el juego, se me han ocurrido dos ideas (todas las sugerencias serán bienvenidas):
 La primera opción es coger directamente la primera palabra (el usuario jamás debe tener acceso a esta lista de palabras, sería trampa) utilizarla para el juego y al terminar, colocarla en el último lugar de la lista. Esta opción es la que menos recursos utiliza y nos va a enseñar mucho sobre cómo manejar ficheros.
La segunda opción es mantener intacto el fichero, copiar todo su contenido y manejarlo de forma interna en el programa. La parte buena es que será mucho más rápido, ya que sólo tendrá que abrir y leer el fichero una vez.

Mañana seguiremos viendo cómo hacer las siguientes partes del programa.