Geisha Studios

Figure 1. Screenshot of hangman with some letters guessed.

Hangman is a simple guessing game in which the player tries to guess a word by suggesting letters until she either finds out the word or has attempted to guess too many times.

This version of hangman is a simple C++ command line application that randomly selects a word from a file and then ask the player to guess letters. The word to guess is represented on screen by a row of dashes (-), one for each letter still to be guessed. Each time the player guesses a letter correctly, the computer will show the letter in the correct position instead of the dash. If the guess is incorrect, then it will draw a piece of a hangman diagram.

The application will start off building a list of words from a file and then will pick up a random word from that list. Then it will ask the player to enter a letter that hasn’t been used already. It will check whether the word contains the entered letter and depending on that will update the screen replacing dashes with the letter or draw another piece of the hangman’s diagram.

The game ends when the player either guesses the word correctly or the hangman diagram is complete. At this time, the application will ask whether to play again with a newly picked word or quit.

Being written in C++ the application can throw exceptions when there’s something wrong, therefore the first thing to do is place a try catch block that catches any exception in order to show the error message and avoid calling abort() due to an exception leaving main.

          
<<main>>=
int main()
{
    try {
        <<hangman code>>

        return EXIT_SUCCESS;
    } catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
    } catch (...) {
        std::cerr << "Unknown error" << std::endl;
    }

    return EXIT_FAILURE;
}

        

I use the EXIT_SUCCESS and EXIT_FAILURE macros defined in C’s standard library.

          
<<includes>>=
#include <cstdlib>

        

I catch all thrown exception objects that derive from the standard’s exception class as well as any other object the application might throw. In the latter case, I just print out an unknown error. If there is no exception thrown, then the application hits the return statement inside the try block and exits with EXIT_SUCCESS.

For this block to work, I need to include the header with the definition of the standard exception classes and the cerr object.

          
<<includes>>=
#include <stdexcept>
#include <iostream>

        

Inside the try block, then, I’ll place the main application’s code.

          
<<hangman code>>=
bool quit = false;
<<build word list>>
<<initialize random number generator>>
do {
    <<pick random word>>
    <<build guess>>
    unsigned int attempts = 0;
    do {
        <<draw current status>>
        <<ask for new letter>>
        <<check whether the letter belongs to the word>>
    } while (guess != word && attempts <= 6);
    <<check whether the player won or lost>>
    <<draw current status>>
    std::cout << "The word was: " << word << std::endl;
    <<ask whether play again>>
} while (!quit);

        

The application will build the list of words to use to play from a simple plain text file. This file is named hangmanwords.txt and is located at the same working directory as the application. If it can’t open the file, it can’t continue and throw an exception. The more appropriate exception in this case is runtime_error, but I don’t need a derived class because I don’t need to add additional information about the error and also don’t need to treat this error specifically.

          
<<open the words file>>=
std::fstream wordsfile("hangmanwords.txt", std::fstream::in);
if (!wordsfile) {
    throw std::runtime_error("Couldn't open words file");
}

        

To use fstream I need to add the necessary header file.

          
<<includes>>=
#include <fstream>

        

Even though I could just read the file line by line to know how many words there are, in an effort to improve efficiency the first line will contain the number of words in the file.

<<hangmanwords.txt>>=
5

This number is just a hint for the application to reserve the memory necessary to hold at least as many words as specified. Given that I don’t need to add nor remove words once they have been read from the file, and since I will access the list in random order, the best structure in which to store the list of words is to use a vector of string. So, after clearing the vector, reserve as many elements as specified in the file.

          
<<reserve space for words>>=
int numberOfWords = 1; // At least I'll have a single word.
wordsfile >> numberOfWords;

wordlist.clear();
wordlist.reserve(numberOfWords);

        

To keep things simple, each word will be in a line of its own and will not have heading nor trailing spaces. The word can’t also have spaces.

<<hangmanwords.txt>>=
unicorn
hangman
boogieman
cromulent
supercalifragilisticexpialidocious

Therefore I need to read the file line by line and store every non-empty word to the vector. To avoid a potential buffer overflow, I’ll use getline defined inside the string header file.

          
<<includes>>=
#include <string>

        

getline reads a whole line from an input stream and stores the contents to a string object. I’ll keep reading words and storing them inside the vector until I’ve read the entire file. I must check if the word is empty before adding it to the list to screen out blank lines.

          
<<read words>>=
while (!wordsfile.eof()) {
    std::string word;
    getline(wordsfile, word);
    if (!word.empty()) {
        wordlist.push_back(word);
    }
}

        

If there is no word in the list, I can’t continue and so throw another exception. Again, given no need to add additional information nor handle this error in any special way, using a simple runtime_error is fine.

          
<<check whether the word list is empty>>=
if (wordlist.empty()) {
    throw std::runtime_error("No words in the list");
}

        

Finally, as the word list could be big, instead of returning the vector as the function’s result value, the function asks for a reference to an already allocated vector object in which it will fill up with the words. Once the function return, the words will be stored in the referenced vector.

          
<<build word list function>>=
void
buildWordList(std::vector<std::string> &wordlist) {
    <<open the words file>>
    <<reserve space for words>>
    <<read words>>
    <<check whether the word list is empty>>
}

        

          
<<build word list>>=
std::vector<std::string> wordlist;
buildWordList(wordlist);

        

To use vector I need to include the appropriate header.

          
<<includes>>=
#include <vector>

        

To pick up a random word from the word list, I’ll use C’s standard rand function. This function returns a number between 0 and MAX_RAND, which is defined inside the cstdlib header. Before using this function, though, I must initialize the random number generator using a seed. This seed needs to be a different number each time the application starts. A good seed in this case is to use the current time in which the application starts.

          
<<initialize random number generator>>=
srand(time(0));

        

The time function is defined inside the ctime header.

          
<<includes>>=
#include <ctime>

        

When the random number generator is initialized, I need to get an index inside the wordlist vector to select a word to guess. I’ll use the output of the rand function limiting its range to the word list’s length using the modulo.

          
<<pick random word>>=
std::string word = wordlist[rand() % wordlist.size()];

        

The application need to keep an string with the same length as the word to guess but with every letter replaced with a dash. The easiest way is to use the string constructor that accepts a length and a character to fill the string with.

          
<<build guess>>=
std::string guess(word.size(), '-');

        

I also need to keep score of the letters the player tried to prevent the player to use the same letter twice. I’ll just add the letters tried to a set of char, which doesn’t allow duplicates.

          
<<includes>>=
#include <set>

        

          
<<build guess>>=
std::set<std::string::value_type> lettersUsed;

        

            
<<draw current status>>=
drawHangman(std::cout, attempts);
std::cout << "Guess:        " << guess << "\n";

          

            
<<draw hangman function>>=
// ASCII ART FTW!
void drawHangman(std::ostream &out, unsigned int attempts)
{
    switch(attempts)
    {
        case 0:
            out << " +----+\n";
            out << " |    |\n";
            out << "      |\n";
            out << "      |\n";
            out << "      |\n";
            out << "      |\n";
            out << "      |\n";
            out << "------+\n";
            break;

        case 1:
            out << " +----+\n";
            out << " |    |\n";
            out << " O    |\n";
            out << "      |\n";
            out << "      |\n";
            out << "      |\n";
            out << "      |\n";
            out << "------+\n";
            break;

        case 2:
            out << " +----+\n";
            out << " |    |\n";
            out << " O    |\n";
            out << " |    |\n";
            out << " |    |\n";
            out << "      |\n";
            out << "      |\n";
            out << "------+\n";
            break;

        case 3:
            out << " +----+\n";
            out << " |    |\n";
            out << " O    |\n";
            out << "\\|    |\n";
            out << " |    |\n";
            out << "      |\n";
            out << "      |\n";
            out << "------+\n";
            break;

        case 4:
            out << " +----+\n";
            out << " |    |\n";
            out << " O    |\n";
            out << "\\|/   |\n";
            out << " |    |\n";
            out << "      |\n";
            out << "      |\n";
            out << "------+\n";
            break;

        case 5:
            out << " +----+\n";
            out << " |    |\n";
            out << " O    |\n";
            out << "\\|/   |\n";
            out << " |    |\n";
            out << "/     |\n";
            out << "      |\n";
            out << "------+\n";
            break;

        default:
            out << " +----+\n";
            out << " |    |\n";
            out << " O    |\n";
            out << "\\|/   |\n";
            out << " |    |\n";
            out << "/ \\   |\n";
            out << "      |\n";
            out << "------+\n";
            break;
    }
}

          

            
<<includes>>=
#include <algorithm> // for copy
#include <iterator> // for ostream_iterator

          

            
<<draw current status>>=
std::cout << "Letters used: ";
std::copy(lettersUsed.begin(), lettersUsed.end(),
    std::ostream_iterator<std::string::value_type>(std::cout, ", "));
std::cout << "\n";

          

            
<<ask for new letter>>=
char letter = '\0';
do {
    std::cout << "Enter a letter: ";
    std::cin >> letter;
} while (lettersUsed.find(letter) != lettersUsed.end() && !std::cin.eof());
// We can't read anymore with a closed stdin.  Quit.
if (std::cin.eof()) {
    return EXIT_SUCCESS;
}
lettersUsed.insert(letter);

          

            
<<check whether the letter belongs to the word>>=
bool guessWordChanged = false;
for (size_t char_pos = 0 ; char_pos < word.size() ; ++char_pos) {
    if (letter == word[char_pos]) {
        guess[char_pos] = letter;
        guessWordChanged = true;
    }
}
// no luck
if (!guessWordChanged) {
    ++attempts;
}

          

            
<<check whether the player won or lost>>=
std::cout << "\n\n";
if (guess == word) {
    std::cout << "YOU FOUND THE WORD!\n";
} else {
    std::cout << "You didn't find the word.  Good luck next time.\n";
}
std::cout << "\n";

          

            
<<ask whether play again>>=
std::cout << "Play again (y/n)? ";
char playAgain = 'n';
std::cin >> playAgain;
std::cout << std::endl;
quit = playAgain != 'y';