CS 115 Project 3, Spring 2017:
Ghost Word Game

[Back to CS 115 schedule]

Summary: In this project, you will make a simple game using the graphics package. Ghost Word is a guessing game modeled after Hangman. One player (or the computer) thinks of a word, and the other player tries to fill in the letters of the word. The game is over when the word is entirely guessed, or when the guessing player reaches 6 incorrect guesses. The player's current number of incorrect guesses is illustrated by drawing a figure that slowly disappears with every incorrect guess; when the figure has entirely disappeared, the guessing player loses.

In this project, you are designing your own functions and expressing them. In contrast to prior assignments, a large part of this assignment is focused on organization, design and coding style. Make simplicity, clarity, efficiency and good style the top goals in your design (see the grading rubric for details). The user interface does not need to match the sample output; instead, feel free to be creative and design your own game with its own "look and feel". The user interface should, however, match the specifications in the assignment and be professional, unoffensive, and enjoyable by everyone.

Due dates:

• Checkpoint A and B: Both are due as demos in any workshop, lab, or tutoring hours before Thursday May 4 at 7 PM.
  This is a final due date for demos (not a target due date): you are encouraged to show Checkpoint A much earlier than B.
• Final code: Due via Moodle on Thursday, May 11 at 11:55 PM

Useful terminology for our program:

• Dictionary: The word list that the game is using
• Secret word: The word that the user is trying to guess
• Revealed word: A string showing the user's current progress at guessing the secret word, with letters that have been guessed filled in and the remaining letters as blanks (underscores).
• Guess: The letter (a single character) guessed by the user

See the below video to see an example of the game being played.

Getting Started

Download the following files into your PyCharm directory for Project 03:

• graphics.py
• ghost_support.py, a support library for this project.
• wordlist_short.txt, a short word list for testing.
• wordlist_long.txt, a long word list for testing.

The file wordlist_long.txt is the official Scrabble dictionary minus some offensive words. You should use it for testing, but your testing should not be limited to using this file. The idea is that the player will create their own wordlist.txt file to stump their friends, and so your program will need to handle other people's wordlists (which might contain invalid words). Read the specification for how your program should react. The file wordlist_short.txt is a selection of harder words from Wolfram's blog, modified to demonstrate some invalid entries that your program will need to handle.

You should write your code in a separate file. To use the support library for this project, add the following line to your file:

from ghost_support import *

Checkpoint A (5 points)

For Checkpoint A, you will need to demonstrate a program that prompts the user for the name of their dictionary file and outputs summary statistics of this dictionary (see below). Then, prompt the user to if they want to play a game of Ghost Word.

To process the dictionary:

• Open the dictionary file and read the contents of the file to form the dictionary.
• The dictionary should be a list of all the words in the file that contain ONLY alphabetic characters. If a word contains any characters that are not alphabetical (a-z or A-Z), do not add the word to the list, and move on to the next one without printing a message.
• If two words only differ in case, then they are the same word
• If you do not end up with any usable (alphabetical) words, you should print an error message and exit the program.

To print the dictionary statistics:

• Print to the screen the first order statistics of the dictionary, including its size and the frequency of each letter across the whole dictionary (ignoring case).
• This should be done once, before the user is prompted to play a game (as in the screen shot, below).

To prompt the user to play a game:

• If the user answers 'Y' or 'y', your program should pop up a square graphical window that is WINSIZE by WINSIZE pixels.
• At the end of any game, the user should be prompted again, asking if they want to play a game of Ghost Word. If they enter 'yes,' the prior game window should close and a new game window should be opened.
• If the user answers 'N' or 'n', your program should exit cleanly.
• If the user answers anything else, your program should repeat the question.

Hints:

• If you have a string variable s, you can call the built-in function s.isalpha() to see if it is entirely alphabetical. This function will return True if the string is entirely alphabetical and False if it is not.
• If you have a string variable s, you can count the number of occurrences of the character 'A' in the string using s.count('A'). This returns an integer value.
• You are welcome to use any file processing functions from our past labs to handle the file I/O operations.

Checkpoint B (5 points)

Your Checkpoint B code demonstates a playable game without any graphics, featuring the below behavior. (Note: without any graphics, this game is indistinguishable from the more familiar game Hangman.)

In every game of Ghost Word, your program should do the following:

• Choose a word from the dictionary using the choose_word function from ghost_support.py.
• Display the revealed word (initially all blanks) in the text window, with spaces between the letters so that it's easy to count the number of blanks. You should print all letters in uppercase and print underscores ('_') for letters that the user has not yet guessed.
• Also print the letters the user has already guessed (initially nothing).
• Let the user guess a letter. If the user's guess is more than one character or is non-alphabetical, you should print a specific error message.
• If the user has already guessed this letter, print a specific error message.
• If the character is alphabetical, check to see if it is in the secret word. This check should be case-insensitive (that is, 'q' and 'Q' should be equivalent):
  • If the character is in the secret word, update the revealed word to reveal that letter. If the user has won (revealed all the letters), print the final revealed word and a congratulatory message.
  • If the character is not in the secret word, update the number of incorrect guesses and the list of letters the user has already guessed. If the user has used up all 6 incorrect guesses, print a message.

Final Code

In your final code, you will extend your Checkpoint B code in two ways:

• In the text window, print the number of words in the word list that match the pattern of the currently revealed word and the list of incorrect guesses.
  • For example, if the revealed word is _ E _ _ and the list of incorrect guesses is T and S, then you would count the words that have 4 letters, with exactly one E (in the second position) and no T's or S's.
  • It is possible to do this using only what we've learned in class, but you are welcome to further explore Python string methods if you like.
• In the graphical window, draw a figure at the beginning of each game, and make one body part of the figure disappear with each incorrect guess. The parts should disappear in this order:
  1. Left leg
  2. Right leg
  3. Left arm
  4. Right arm
  5. Body
  6. Head
  Your drawings can be simple stick figures (see below), or they can be as elaborate as you like. They should, however, be sized to take up at least 75% of the vertical space in the window.

There is no demo for your final code. See the end of this specification for submission instructions, including a grading rubric.

Grading

Correctness [55%]

The most important part of your grade is the correctness of your final program. Your program will be tested numerous times, using different inputs, to be sure that it meets the specification. A detailed grading sheet for this project is posted here.

Programming Design and Style [35%]

In addition to being correct, your program should be easy to understand and well documented. For details, see the grading sheet above.

Checkpoints [10%]

Your checkpoints are each worth 5 points, as described above. The checkpoints cannot be submitted late.

Extra credit [up to 5%]

There are lots of possibilities to extend this project for extra credit. If you have an idea you'd like to implement, then (at least a day before final code submission) you need to propose it in a private note sent to 'Instructors' on Piazza and get approval for your feature. You are responsible for making sure it is possible to satisfy the whole project grading rubric while also encorporating your extra credit.

If you don't get your extra credit feature approved, you won't get credit for it (I am likely to think you just implemented your code strangely, or mis-read the assignment). If you discuss it with me in person, it is not enough --- it must be in writing.

Submitting your final code

You should submit your final code on Moodle by the deadline. As a backup, I strongly encourage you to upload a copy to your blue directory in case something goes wrong with your submission to Moodle.

Please name your file yourlastnameP3.py, substituting your actual last name (in lowercase) as indicated.

You should submit only yourlastnameP3.py to Moodle. (The only exception to this is if you have implemented extra credit that requires other files, in which case you should submit all these files as a single ZIP file.)

Collaboration policy

Programming projects must be your own work, and academic misconduct is taken very seriously. You may discuss ideas and approaches with other students and the course staff, but you should work out all details and write up all solutions on your own. The following actions will be penalized as academic dishonesty:

• Copying part or all of another student's assignment
• Copying old or published solutions
• Looking at another student's code or discussing it in great detail. You will be penalized if your program matches another student's program too closely.
• Showing your code or describing your code in great detail to anyone other than the course staff or tutor.

Late policy

There is a 48-hour grace period associated with the final project deadline. This grace period is designed to only cover small personal emergencies and other unexpected events. No other consideration will be given for these small emergencies.