practice using Top-Down Design to design a complex program

write a complex program, with multiple functions, from scratch

practice with interactive implementation and testing of functions in a large program

practice using file I/O

Part 1: for the first week you will work with a partner and focus on using top-down design to create the overall structure for the program. Once your proposed structure has been reviewed and approved by your professor, you will move on to the second part.

Part 2: is to be done individually use a bottom-up implementation to complete the full program based on your design in Part1.

Get a randomly chosen word from the file of words. The word file you will use is "/usr/local/doc/wordfile.txt". We will discuss file I/O in class on Monday.

Display the puzzle with guessed letters filled and - for un-guessed letters at the start of each round.

Display the the number of incorrect guesses left at the start of each round.

Optionally draw the state of Melty at the start of each round.

The user can enter either an upper or lower case character for a letter guess.

Tell the user that they have already guessed a letter, and let them pick again.

Print out a message indicating if the user guessed a correct letter in the word or not.

End the game when the user guesses all the letters in the word or when the player runs out of guesses.

Print out a message at the end of the game indicating if the player won or lost, and print out the word if not.

Use good modular design, including at least 5 different function-worthy functions.

All functions should have complete comments, and use meaningful variable and parameter names

Be robust to some invalid input, such as detect and handle if the user enters an invalid character value as a choice (e.g., "hello" or "6")

create design-melty.py first

when you have a working design you and your partner should (for more details on these steps, see: Section 2.3):

After you have heard back from use with comments on your design, either:

main() should call the top-level functions in your design, in the appropriate order, and with arguments that match parameters. Return values should be assigned to local variables in main even if main doesn’t do anything with them yet.

All functions be stubbed out with parameters, a block comment, and a return statement. They don’t need to do anything yet, except possibly call other functions.

If a function returns a value, in the stubbed out version have it return some value of the correct return type. For example, for a stubbed out version of a sqrt function, I might have it return 0.0 and then later when I implemented the function, change the return statement to return the correct value.

Your design should contain several functions, 5 at a minimum. Each should be function worthy (not a trivial task), and each should demonstrate encapsulation (have a clearly defined purpose or functionality).

Your design-melty.py design should run without syntax errors (i.e. each function called from main should work even if it doesn’t do much more right now than return).

main should just reflect the high-level steps of your program. Details of steps should be encapsulated in functions called by main. It is okay if main contains very high-level game playing loop, but often it is better to have this in a separate function. They key is that main is very simple, easy to read, and reflects the big steps of the program.

use meaningful names for functions, variables and parameters

be robust to some bad input

be well commented

not have any wrapped lines (use the line continuation character \ to handle any stmts that are longer than 80 columns

Look at some of the example file I/O code from Monday’s class for how to read in one or more of the words from this file.

Look at some of the random libary functions to find one that might be helful for choosing a random word from the words in this file.

Use incremental implementation and testing as you go. Implement all or part of a function, and add a test call to it to test it for correctness. Then add a bit more.

You will need to keep track of the puzzle solution (the word chosen), the parts of the puzzle that have been guessed and have not yet been guessed, and the set of letters already guessed. Using separate lists for these three will yield less complicated code.

You can convert a string to a list of characters (single character strings) like this:

  word = "hi there"
  lst  = list(word)  # convert a string to a list
  print(lst)         # ['h', 'i', ' ', 't', 'h', 'e', 'r', 'e']

Some common string methods

Some common list methods

Some common file methods

random library functions

Use a comment at the top of the file to describe the purpose of the program (see example).

All programs should have a main() function (see example).

Use variable names that describe the contents of the variables.

Write your programs incrementally and test them as you go. This is really crucial to success: don’t write lots of code and then test it all at once! Write a little code, make sure it works, then add some more and test it again.

Don’t assume that if your program passes the sample tests we provide that it is completely correct. Come up with your own test cases and verify that the program is producing the right output on them.

Avoid writing any lines of code that exceed 80 columns.