Lab 6: Hangman Due: 11:59 PM on 2020-04-09

For this lab, you will implement a text-based version of hangman. There are many variants of this game, so make sure to follow the specifications exactly. You can also play a demo version of the program you will be implementing. See the prelab for details on how to do this.

Read through the whole lab first before getting started. We provide an overview of how to proceed and some hints near the end.

Specifications

Download the starter file.

Playing the Game

When the program starts it reads a file containing a list of possible words. Download a text file with CS words (recall right click on the link and select “Save link as…” to download). Remember, this file needs to be in the same directory as your program.

After reading the file, the program randomly selects one of these words as the word that the user is trying to guess and then displays the following:

-----------------
Guessed letters: 
Incorrect guesses left: *******
Word: _______

This display has three main components:

1. Guessed letters: Shows the letters the player has guessed so far. The letters will be separated by a space and should be all capitalized. When the game starts, no letters have been guessed, so this area is blank.
2. Incorrect guesses left: Shows the remaining number of wrong/incorrect guesses the player has before the game is over. Each remaining guess is represented as an ‘*’. In this version of the game, the player starts out with 7 incorrect guesses.
3. Word: This shows the word that the player is trying to guess. Each underscore (_) represents a letter in the word. The word above is 7 letters long. As the user plays, the correctly guessed letters will be filled in.

The program runs by repeatedly prompting the user for the next letter. When the user enters a letter, there are three possible scenarios:

1. If the letter has been previously guessed, then the program lets the user know with the message “Letter already guessed!” and prompts the user for another letter.
2. If the letter has not been guessed before, but does not occur in the word to be guessed, then the number of incorrect guesses available is decremented by one and then the display is shown again, prompting the user for another letter.
3. If the letter has not been guessed before and does occur in the word, then the underscored word is updated, with all occurrences of that letter in the appropriate place.

The following transcript shows all three of these different situations happening as the game is being played:

-----------------
Guessed letters: 
Incorrect guesses left: *******
Word: ____

Guess a letter: e
-----------------
Guessed letters: E 
Incorrect guesses left: *******
Word: _e__

Guess a letter: a
-----------------
Guessed letters: A E 
Incorrect guesses left: *******
Word: _ea_

Guess a letter: r
-----------------
Guessed letters: A R E 
Incorrect guesses left: ******
Word: _ea_

Guess a letter: s
-----------------
Guessed letters: A S R E 
Incorrect guesses left: *****
Word: _ea_

Guess a letter: a
Letter already guessed!
Guess a letter: s
Letter already guessed!
Guess a letter: t
-----------------
Guessed letters: A S R E T
Incorrect guesses left: ****
Word: _ea_

Guess a letter:

The game ends when either the user runs out of guesses, in which case the word is shown:

The word was: heap
Better luck next time!

or if the user fills in all of the underscores in the word, then the user wins and the number of incorrect guesses is printed out:

Guessed letters: A H S R E 
Incorrect guesses left: *****
Word: hea_

Guess a letter: p
You win!
The word was: heap
You guessed it with 2 incorrect guesses

Implementation Specifications

Besides following the game specification described above, your program MUST meet the following requirements:

Your program must contain at least the following four functions:

1. read_words, which has a filename as a parameter and returns a list of the words in the file (you can assume the file contains one word per line).
2. set_to_string, which takes a set as a parameter and returns the letters in the set as a string, with each letter capitalized and separated by a space.

3. insert_letter, which has three string parameters: a letter, the current underscored word and the word the user is trying to guess. This function should return a new version of the underscored word with all occurrences of the letter filled in based on the occurrences of the letter in the word to be guessed. See an example below.

   >>> insert_letter("a", "__n_n_", "banana")
   '_anana'
   

4. play_hangman, which has two parameters, the filename that contains the candidate words and the number of incorrect guesses the player gets. This function should then initiate the hangman game and continue to run until the game finishes.

and meet these additional specifications:

• Your program should properly use the above four functions.
• You must use a set to store the guessed letters.
• Your program should immediately start playing the game with a default of 7 incorrect guesses when it is run with the green arrow. Do so by calling play_hangman from within the if __name__ == "__main__" conditional in the starter file. The play_hangman function should only be called from within that conditional.
• Your program should be case insensitive, i.e., identically handle upper-case or lower-case letters as input.
• The guessed letters shown should all be capitalized.

Guide

One potential development approach

There are many different ways to implement your program, but here is one suggestion:

1. Implement the read_words function and make sure that it correctly reads in the words in the file to a list. Don’t forget to remove the newline characters at the end of each line when reading in the words.
2. Implement the set_to_string function. This should be very similar to the function you wrote for the prelab. Recall that sets are iterable, so you can iterate over the items in a set just like you can with a list.
3. Implement the insert_letter function. There are many ways to implement this function, but one way is to build up the new string letter by letter (like we did for the encryption functions). For each letter in the new underscored word you’re creating, you either just copy what was in the underscored word before, or, if the letter appears in the word to be guessed at that position, you copy the correct letter.

4. Implement play_hangman incrementally, testing each step before moving on to the next:

   1. Read in the file, pick a random word and then display the underscored word. While you are developing, print out other information (like the word you’re supposed to be guessing) to help you debug your program. Just make sure to remove this information before you submit.
   2. Add the user input and add the letter that the user guessed into the underscored word appropriately (your functions from above should be useful).
   3. Add in functionality to keep track of the letters the user has guessed and to print out the letters guessed.
   4. Add the functionality to make sure that the user continues to be prompted to enter a new letter as long as the letter input has already been guessed.
   5. End the game when the user gets the right answer.
   6. Keep track of the number of incorrect guesses and also end the game when the user runs out of guesses.
   7. Print out the appropriate win or lose information.

Hints

• How do the four functions fit into the program? Each of them should play a role in your program. Thinking through their role first will make you more efficient and your program simpler.
• What information does your program need to keep track of (e.g., letters guessed, word to be guessed, underscored word, etc.)? Make sure you think about how you’re storing each of these pieces of information.
• If you’re confused about the behavior of your program, put in more print statements to print out variables, etc., or create a test scenario in the shell.
• Remember, if your program hangs when you run it, you probably have an infinite loop. You can hit Control-C to stop it, or restart the shell by clicking on the stop sign. Try adding print statements to your loops to figure out where the problem is.
• This program should not be a lot of code, but some of it can be tricky. Make sure you think about how you want to accomplish each step. Sometimes it helps to write down what you want to do in English (i.e., pseudocode), focusing on the logic, and then translate this into code.

Creativity Points

You may earn up to 2 creativity points on this assignment by adding improvements to your program. If you do, include in your comment at the top of your program what you added. Here are some ideas that you might consider:

• [0.5 point] Currently, we don’t do any error checking to make sure that the user is providing valid input, i.e., a single letter. Add these additional checks and re-prompt the user to enter another character on invalid input.
• [1.5-2 points] Rather than using asterisks (‘*’) to represent how many guesses the person has left, display a text-based stick figure, for instance, like the one shown below. I’m sure you can do better, though! In the real game, a part of the figure is added for each wrong guess.

|-----|
|     O
|    \|/
|     |
|    / \ 

When you’re done

Make sure that your program is properly commented:

• You should have a comment at the very beginning of the file stating your name, section and creativity additions.
• Each function should have an appropriate docstring (including arguments and return value if applicable).
• Other miscellaneous comments to make things clear

In addition, make sure that you’ve used good coding style (including meaningful variable names, constants where relevant, vertical white space, etc.).

Submit your program via Gradescope. Your program program file must be named lab6_hangman.py. You can submit multiple times, with only the most recent submission (before the due date) graded. Note that the tests performed by Gradescope are limited. Passing all of the visible tests does not guarantee that your submission correctly satisfies all of the requirements of the assignment.

Grading