CSCI 161c: Introduction to Computer Science • Fall 2012 • University of Puget Sound

Quick Links: Home • Schedule • Labs • Homeworks • Resources

CSCI 161 Homework Assignment 7 - Graphical Hangman

Due Fri Nov 02 at 11:59pm

Introduction

Over the past few weeks, we've managed to make a pretty spiffy Hangman program. We can play multiple games of Hangman, and we can even make the game evil so that the player (almost) always loses. For the assignment, we're going to add a nice graphical user interface (or "GUI") to the game, so that it draws a pretty picture as we're playing. We're also going to package the whole game into a single file, so that you can easily show it to your family and friends! This homework will give you a chance to practice using the Canvas object and writing programs that can be run without BlueJ.

The Assignment

You will be continuing to extend your Hangman game, adding a graphical interface that shows the gallows and draws a picture. You will also package the whole game into a .jar file.

As always, be sure to download and unzip a FIXED copy of the the Homework 7 project. so that you can submit your project once completed. This project also contains some extra classes you can use in programming your game (the same WordList class from before, a Canvas like you used in lab, and a HangmanButtons class that gives you some buttons you can use to control your game).

Note: Once again, you will need to copy your HangmanGame class from the last assignment into this one! Make a new HangmanGame class in the Homework 7 project, but copy and paste the code from Homework 6 into it. You should use your evil hangman program (which, remember, can be either good or evil). Make sure that you can run this class and it works just like the last homework. If you didn't finish that homework, you can use the solution to Homework 5 (linked from the last assignment), though you will be missing the evil functionality.

Remember to read all the way through the instructions carefully! I reserve the right to not answer questions that are already answered in the assignment ;p

1. Read the assignment

   Read all the way through the assignment carefully. Make sure you understand the big picture and what each step will accomplish. Then when you get to each step, focus on just that step, testing until you have it right!

2. Make new constructor and field for HangmanGame

   The Hangman game is going to need to a Canvas to draw on, so give it one. You'll need to make a new variable of the Canvas type to hold the Canvas object. Should this be a local variable or a field? Are multiple methods going to need to access it?

   • Declare and instantiate the variable. If it is a field, you'll need to make sure to initialize it in all of your constructors.
   • You should also make a new constructor (a third one!) that takes in a single parameter a new Canvas object on which we can draw. This way the user can specify a different canvas for us to use if they want.
   • You can test that this works by seeing if making a new HangmanGame (using BlueJ) and seeing if the blank canvas shows up
3. Make the drawGallows() method

   Start by drawing the gallows, which should always show up when the game is being played. Make a new method that just draws the gallows on your canvas.

   • If you're like me, you'll probably need to experiment with line lengths and coordinates in order to make something that looks good.
   • Test this method to make sure your gallows appear and look the way you want!
4. Make the drawCurrentGuess() method

   Next add in the "current guess"--the word with guessed letters revealed (i.e., the underscores). Make a new method that just draws the guess on your canvas.

   • Note that we should already be able to convert the current guess to a String using the only-sorta-aptly-named currentGuessString() method.
   • This method is a little bit harder to test--you should be able to call it and see the underscores, but how do you make sure letters are showing up? One thing you can do is first call checkGuess() a few times to "guess" letters and add them to your word, and then call this method to see if they show up correctly.
5. Make the drawHangedMan() method

   Now add in the hangedman--that is, the stick figure that is drawn as the user misses letters. Make a new method that just draws the figure on your canvas.

   • This method is going to have some logic in it! You'll need to draw pieces of the hangedman based on how many wrong guesses the player made (or equivalently, how many lives they have left). First you draw the head, then the body, then one arm, then the other, then one leg, then the other.
   • Note that this method should draw the entire figure based on the number of lives--so if I currently have made 2 wrong guesses, it draws the head and the body.
   • You can test this method by locally setting the number of lives, then calling this method from BlueJ (in other words, make it so the method sets the appropriate nubmer of lives for testing). Just make surethat you delete that local assignment before you continue!
6. Make the redrawCanvas() method

   Finally, make a method that will perform all of the above actions and "draw" your current hangman game.

   • This method should erase the current canvas, draw the gallows, draw the current guess, then draw the hangedman.
   • This method is easy to test!
7. Call the redrawCanvas() method from your code

   Now that you've giving your game the ability to be drawn on the Canvas, add this functionality to your playGame() method! Modify your playGame() method so it draws the output to the Canvas in addition to printing to the console.

   • Basically, where-ever you print your guess to the console (such as at the start of your game loop), you'll want to add in a call to redrawCanvas().
   • You'll also want to add a call to JOptionPane.showMessageDialog() whenever you report to the user that they missed a letter, or used an already guessed letter, etc.
   • Note that we add in the GUI interactions in addition to printing to the console so that the game can still be played without the GUI. Flexibility is king!
   • Test that this works--you should be able to smoothly play a game of Hangman without looking at the console (or without looking at the Canvas!)
8. Make the HangmanGUI class

   For this program, you'll need to create a new class called HangmanGUI to create the different parts of the GUI. We do this in a separate class in order to support better encapsulation, cohesion, and coupling (see Chapter 6). This class is very simple: see the documentation below.

   • The class should have three things in it: a Canvas to draw on, a HangmanGame object that is the game we'll play, and a HangmanButtons object to create the control buttons. Check the parameters for the constructors of each of these objects--in what order do you need to create the objects so that you can pass a previously defined variable to the constructor? THINK!
   • Note that the buttons SHOULD work, since they just execute the playGame() and toggleEvil() methods of your HangmanGame. That is, you should be able to click on these buttons and get the exact same effect you had by right-clicking on the object in BlueJ and selecting the relevant method.
   • Test your HangmanGUI class--making a new GUI object should give you a set of working buttons.
9. Refactor the Canvas object into the HangmanGUI class

   This is almost complicated, read these instructions carefully!

   Now that you know that everything works, you'll want to pull the Canvas object OUT of the HangmanGame class, and instead use the Canvas object that you defined in your HangmanGUI class. You can pass a reference to this Canvas object using the appropriate constructor of the HangmanGame class. In other words, your HangmanGame will use the Canvas supplied by the GUI, instead of making its own.

   • This produces cleaner, more maintainable code (it means that we can change the Canvas, a GUI element, without needing to change the HangmanGame code). And we can play HangmanGame without the GUI if we want!
   • Additionally, you should make it so that the redrawCanvas() method only gets called if the HangmanGame has a canvas. If the HangmanGame wasn't given a Canvas object, then that field should be null. You can check if the HangmanGame has a canvas using: if(canvasField == null)
10. Test and clean-up your code

    Make sure the game plays how you want it to, shows the right messages, etc. You want this to look good, so you can show it off to your friends and family! Remember, this is an entire program that you wrote from scratch!

11. Make the HangmanGUITester class

    It's good programming style to make our program that we can run ("execute") outside of BlueJ have a single class that actually does that running. We generally name these ___Tester, where ___ is the name of the class we would instantiate in BlueJ to start things. In this case: the HangmanGUI. So make a new HangmanGUITester class.

    • This class will be disgustingly simple. It will contain a single method: public static void main(String[] args) (see Appendix E in the book).
    • Your main method will have a single line of code: creating a new HangmanGUI object. Thus calling the static main method--which will be called when you start the program--will create the HangmanGUI object, just like if you had selected it from BlueJ.
12. Fill in documentation (if you haven't already!)

    Be sure to document all your code clearly using Javadoc comments and tags for each class. In addition, be sure to include inline comments explaining how your code works--particularly if you have a complicated sequence of if statements. NOTE: Private methods will not show up in BlueJ's Javadoc window, but you should still include Javadoc style comments for these. After you are done testing, feel free to make any of your helper methods private instead of public (this is better design).

13. Create an executable jar file

    Now that your program is all written and works (it does work, right?), you can export it as an executable file that someone can double-click and run, just like any other program.

    • In the BlueJ menu, select Project > Create Jar File.... Your "main class" will be the HangmanGUITester. You should be sure to include the source files and BlueJ Project Files in your jar, so that the word list gets included!
    • Make sure you save the new jar file in the same folder as the rest of your project (so that you can submit it!). You should name this file Hangman.jar.
    • You can test that this file works by double-clicking it--it should run your hangman game!
14. Test that everything works, and then submit!

Extensions

The same extensions from previous homeworks apply to this homework; if you haven't done them yet, you can do them now!Remember to save a working copy of your code before trying any extensions, just in case something breaks!

• Make it so your game also displays any currently guessed letters on the Canvas. Bonus points if you list them in alphabetical order!
• Make the guess display in a more interesting (but still readable!) font. See the java.awt.Font class.
• Support a greater number of guesses--such as by drawing in a face of the hangedman. This is particularly appropriate for Evil Mode.
  • Bonus: allow the user so specify the number of guesses (perhaps picking from an "easy" "medium" or "hard" option), and then have your game react appropriately.
• Draw something other than a stick figure being hanged--perhaps a robot?

Submitting

As always, before submitting, test each of your methods and classes thoroughly. Make sure your game works exactly as expected! When you're convinced it's ready to go, submit the project through BlueJ just like you did in the previous Assignments (selecting Hwk7 of course).

Submitter will look for the HangmanGame.java, HangmanGUI.java, HangmanGUITester.java, and Hangman.jar files (whew!).

Grading

This assignment will be graded on the following criteria:

• Your program can play both normal and evil hangman [10%]
• Your program displays a canvas, with the gallows, word, and figure drawn on it [25%]
• Your canvas is updated as the user plays the game [15%]
• You have a separate HangmanGUI and HangmanGUITester classes to organize your code [10%]
• Your program can be run from an executable jar file [20%]
• Your code is carefully documented, with proper Javadoc methods [10%]
• Your code uses good style. This means that variables are given descriptive names, local variables aren't specified in the fields, methods are properly refactored, redundant code is expunged, etc. If you have any questions about good style, don't hesitate to ask! [10%]

Documentation

java.lang.Object
  HangmanGame

java.lang.Object
  HangmanGUI

java.lang.Object
  HangmanGUITester

Joel Ross • jross@pugetsound.edu

Page Last Modified: 2012-11-01 13:26:21 -0700

Mathematics and Computer Science Department • University of Puget Sound