and I would like to preface this by saying this is NOT a current homework assignment; but it is an assignment from 3 years ago before I dropped out of school. I am self teaching and am revisiting an old assignment. I am NOT asking for the entire program, I'm simply looking for help building the skeleton for the initial start of the game.

MORE INFO: Player 1 will enter word(of any length / i have been using "Testing") for Player 2 to guess. Player 2 will have 5 letter guesses, and 5 word guesses. If Player 2 enters "Testing" it should be able to ignore the case between upper/lower (WITHOUT using toupper / tolower) IF: Player 2 enters more than 1 letter for a guess: "aa" make them guess again until they only guess 1 letter "a".

The problems I'm facing is: I don't know where to place everything, I feel I'm mixing up or messing up the functions, and everytime I try to organize it, it only gets worse. I've restarted it several times, I'm just having trouble getting it all laid out.

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

int main()
{
    string word, wordguess, lower, dashes;
    string letterguess;
    int i = 0;
    bool GameOver = false, Validletterguess = true, Validwordguess = true;    


    cout << "Player 1, enter a word for Player 2 to guess: " << endl;
    getline(cin, word);
    cout << endl;
    cout << "Player 2, you have 5 letter guesses, and 5 word guesses." << endl;
    cout << "Guess your first letter: " << endl; 

    while (GameOver == false) // Start of Game. Setup for Round 1 letter guess and word guess.
    {           
      
        while (letterguess.length() != 1) // 1 letter only. loop until they enter 1 letter
        {
            cout << endl << "Type a single letter and press <enter>: ";
            cin >> letterguess;   // enter letter guess          

            for (int i = 0; i < letterguess.length(); i  ) //ignore case of letter guess
            {
                if (letterguess.at(i) >= 'A' && letterguess.at(i) <= 'Z') 
                {
                    lower  = letterguess.at(i)   32; 

                }
                else
                {
                    lower  = letterguess.at(i); 
                }  

            }  
            if (letterguess.at(i) == word.at(i) && Validletterguess == true) //if Player2 guesses a correct letter, replace the dash with letter and display location: ex. If "T" then "You guessed the 1st and 4th letter"
            {
                cout << "You guessed the first letter right!" << endl; // figure out how to display dashes? 
                dashes.at(i) = letterguess.at(i);
                cout << "Enter your first word guess: " << endl;
                cin >> wordguess;
            }
            else
                cout << "Wrong letter! Enter your first word guess: " << endl;
                cin >> wordguess;      

            if (wordguess == word & Validwordguess = true)
            {
                cout << "You guessed the word correctly in 1 try! " << endl;
                Gameover = true;

            }

        }
      

    }   
       
        

        
        
    }

CodePudding user response：

There are several things in C that can assist you. It's good to see that you're already using std::string and std::getline to deal with the user input. The problem seems to be that you've gotten tangled up in organizing the game logic so that it flows, and setting up structures that can help you.

I did actually go ahead and write a game just for kicks. The hope is that I can provide some of that and describe it so you can digest in chunks, and you can see how one can build a program up a bit at a time.

So let's start by making a stub for the function that will actually run the game. You can call this from main. It simplifies the actual running of the game by separating it from the other setup and shutdown stuff. It also means you can run several games in a row later, without having to modify the game loop.

enum GameResult {
    None,
    Win,
    Loss,
};

GameResult PlayHangman(const std::string& target, int wrongLetterLimit, int wrongWordLimit)
{
    return None;
}

And to illustrate that point, here is the full main that I ended up writing to invoke this game. Even though it's a one-off, you can see that it can be useful. In this case, I chose to read the game settings from the command line:

void ExitSyntaxMessage(int code = -1)
{
    std::cerr << "Syntax: hangman <word> [guesses [wordGuesses]]\n";
    exit(code);
}

int main(int argc, char** argv)
{
    // Get game settings
    std::string target;
    int letterGuesses = 5;
    int wordGuesses = 5;

    try {
        if (argc < 2) throw std::runtime_error("Not enough arguments");
        target = argv[1];
        if (argc > 2) letterGuesses = std::stoi(argv[2]);
        if (argc > 3) wordGuesses = std::stoi(argv[3]);
    }
    catch(...)
    {
        ExitSyntaxMessage();
    }

    // Play game
    GameResult result = PlayHangman(target, letterGuesses, wordGuesses);

    // Deliver result and exit
    switch(result)
    {
    case Win:
        std::cout << "Congratulations!\n";
        return 0;
    case Loss:
        std::cout << "Better luck next time!\n";
        return 1;
    default:
        std::cout << "Game stopped.\n";
        return -2;
    }
}

So, now there's a simple framework for your game to run in. There's not much code, but it's something you can immediately start testing before moving on to fleshing out the game itself.

At this point, I should mention some headers that this program will be needing. Some will have been required already. Others are required for stuff we're about to do.

#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include <set>

On to the game... A helper function to turn a string into lowercase is always handy. We'll definitely make use of that. Note that this uses a lambda function. If you don't have a modern C compiler (with C 11 support) you can just use an ordinary function pointer instead.

std::string Lowercase(const std::string& s)
{
    std::string lc(s);
    std::transform(lc.begin(), lc.end(), lc.begin(),
        [](char c)->char{ return std::tolower(c); });
    return lc;
}

Now it's time to expand on the PlayHangman stub. It's still gonna be a stub, but we can set up a few things that we'll be needing and get those tested before proceeding.

GameResult PlayHangman(const std::string& target, int wrongLetterLimit, int wrongWordLimit)
{
    GameResult result = None;

    // Create lowercase target and add its characters to set of remaining letters
    std::string lcTarget = Lowercase(target);
    std::set<char> lettersRemaining(lcTarget.begin(), lcTarget.end());
    std::set<std::string> guesses;

    // Set up game parameters
    int letterGuessesRemaining = wrongLetterLimit;
    int wordGuessesRemaining = wrongWordLimit;

    // Sanity-test to ensure game is winnable
    if (wordGuessesRemaining == 0 && letterGuessesRemaining < lettersRemaining.size())
    {
        std::cout << "Game is not winnable...\n";
        return None;
    }

    // Game loop until stream error or game finishes
    bool done = false;
    while (!done)
    {
        done = true;  // The loop is a stub for now
    }

    //// ^^^ for now, just use this bit to test the game setup stuff.
    //// Make sure that your lowercase bits are working and the set of
    //// remaining letters works.  You can add some output code to debug
    //// their values and run tests from the command line to verify.

    return result;
}

That is going to be the primary structure of a single game. So let's talk about it. Notice again how I'm still not going into detail. At this point, I've already thought about how I should logically be running the game.

Now, I should say that in reality, most people don't write code in a linear way like this from the outside in. It's more of an organic process, but I do take care to separate stuff out into logical bits, and reshuffle/organize stuff as I go. I also try not to do too much at once.

You'll see by the way I've presented this, that I'm encouraging you to develop a solid platform in which to write your game logic. By the time you're writing that logic, you should be able to trust that everything else already works because you tested it.

Some things happening up there are:

• The target string is copied into a lowercase version of itself. This will be used to test the word-guesses. There are other ways to test strings ignoring case, but this is just a simple way.
• Because we've built that string, we can also use it to construct a std::set containing exactly one of each unique character in that string. That's a one-liner, constructing the set from the string's iterators. Very neat and tidy!
• We also have a set of strings called guesses -- this will track all the guesses (correct/incorrect inclusive) so that you don't get penalized for accidentally repeating something you already guessed.
• There's a sanity check, which is a duplicate of what will eventually be the end-game test inside the loop. To be honest, that was one of the last things I added, but I've put it here because it's part of the pre-game setup, and apart from the stubbed loop, this is the entire "game" sequence.

Checkpoint : Game skeleton complete

At this point, you might have seen enough to go off and complete the game. There are some important concepts introduced up there. In particular, the idea of storing the remaining letters as a std::set might be just the kind of trick that makes everything click into place.

Reading from here on will complete the program. It's up to you whether you want to do that, or stop reading and have a crack at it yourself first.

Let's start fleshing out some of the game loop. First, you probably wanna deal with showing the current game state and requesting input. That happens in two steps. The first part builds a string by hiding characters that are not yet guessed and then outputs it. The second part is an input-validating loop that discards empty lines, ignores duplicate guesses and handles end-of-stream.

Note that the input is converted to lowercase. This just simplifies things. Especially when checking for duplicate guesses.

    while (!done)
    {
        // Create prompt from original string with a dash for each hidden character
        std::string prompt(target);
        for(char& c : prompt)
        {
            if (lettersRemaining.count(std::tolower(c)) != 0) c = '-';
        }
        std::cout << prompt << "\n";

        // Get input
        std::string input;
        for (bool validInput = false; !validInput && !done; )
        {
            std::cout << "> " << std::flush;
            if (!std::getline(std::cin, input))
            {
                done = true;
            }
            else if (!input.empty())
            {
                input = Lowercase(input);
                validInput = guesses.insert(input).second;
                if (!validInput)
                {
                    std::cout << "You already guessed that!\n";
                }
            }
        }
        if (done)
            continue;

        // TODO: Process guess, update game state, and check end-game conditions
   }

Once again, we have expanded on the implementation and now have something to test. So make sure it all compiles and works the way you want it to. Obviously the game will run forever right now, but that's fine -- you can just terminate the process.

When you're happy, move on to the actual logic. This is where we start putting together everything that has already been set up.

Thanks to our input loop, we now know that the input is now a new guess comprising either 1 letter or a word. So I start by branching for either the letter guess or the word guess. You should start to see a pattern here, right? Once again, I write an empty section of code to do something, and then start actually filling it in...

        // Check the guessed letter or word
        bool correctGuess = false;
        if (input.size() == 1)
        {
            if (letterGuessesRemaining == 0)
            {
                std::cout << "No more letter guesses remain.\n";
            }
            else
            {
                // Test the guessed letter
            }
        }
        else
        {
            if (wordGuessesRemaining == 0)
            {
                std::cout << "No more word guesses remain.\n";
            }
            else
            {
                // Test the guessed word
            }
        }

So, the letter test... Recall we already built the lettersRemaining set and tested it. And those are the only ones obscured by dashes in the prompt. So it then becomes trivial to determine whether they guessed one. If it's in the set, they guessed correctly and you remove it from the set. Otherwise, they burn up one of their guesses.

Because the input is already lowercase, we can use the letter verbatim to search within the values stored in the set (which are also lowercase).

                // Test the guessed letter
                char letter = input[0];
                if (lettersRemaining.count(letter) != 0)
                {
                    correctGuess = true;
                    lettersRemaining.erase(letter);
                }
                else
                {
                    std::cout << "Nope!\n";
                    --letterGuessesRemaining;
                }

The word test is even easier. Recall that we stored a lowercase version of the target word already, and the input was also converted to lowercase. So we just compare. You see how all this lowercase business has actually made life less complicated?

                // Test the guessed word
                if (input == lcTarget)
                {
                    correctGuess = true;
                    lettersRemaining.clear();  //<-- we can use this to test for a win
                }
                else
                {
                    std::cout << "Nope!\n";
                    --wordGuessesRemaining;
                }

We are quite literally almost done! The only thing left to do is check whether the game should stop due to being won or lost. That's the last part of the game loop.

Because the code handling a correct word guess is also polite and clears the lettersRemaining set, we can use that as a test for a winning condition regardless of whether a letter or word was guessed.

You'll also see that bit of logic again for the game losing condition. Recall that from before the main loop where we checked if it was even possible to win.

        // If guessed incorrectly, show remaining attempts
        if (!correctGuess)
        {
            std::cout << "\nAttempts remaining: "
                << letterGuessesRemaining << " letters, "
                << wordGuessesRemaining << " words.\n";
        }            

        // Check if game is complete
        if (lettersRemaining.empty())
        {
            std::cout << target << "\n";
            result = Win;
            done = true;
        }
        else if (wordGuessesRemaining == 0 && letterGuessesRemaining < lettersRemaining.size())
        {
            std::cout << target << "\n";
            result = Loss;
            done = true;
        }

I hope this has been helpful, that you've been able to follow along, and that you understand the breakdown and explanation. This is generally how I approach programming. I like to build up pieces of code that I can rely on, instead of getting lost in some details and overlooking more fundamental things.

There may be some techniques, language features or parts of the standard library used here that you have not encountered before. That's fine -- you can use that to learn, experiment and research online. Keep https://cppreference.com bookmarked in your browser.

If nothing else, I hope that this gives you some insight in breaking down tasks into small bits that you care about now, and other stuff that you can worry about later. Building up a program iteratively this way enables you to test code regularly and increases your chances of finding silly mistakes that could hamstring you later. It is so common to see beginners just write a whole program in one hit, run it, then freak out because it doesn't "work".