Question

For a C program hangman game:

Create the function int setup_game [int setup_game ( Game *g, char wordlist[][MAX_WORD_LENGTH], int numwords)] for a C program hangman game. (The existing code for other functions and the program is below, along with what the function needs to do)

What int setup_game needs to do

setup_game() does exactly what the name suggests. It sets up a new game of hangman. This means that it picks a random word from the supplied wordlist array and puts that into g->hidden_word. It sets the number of wrong guesses to zero, and initialises the guesses array to be empty (all zeroes). To select a random word, just pick a random number between 0 and numwords-1, and copy that element of wordlist into the hidden word part of the structure.

   // Data that is in g (Game)

    // g->wrong_guesses

    // g->guesses

    // g->hidden_word

int setup_game ( Game *g, char wordlist[][MAX_WORD_LENGTH], int numwords )

{

// picks a random word from the supplied wordlist array and puts that into g->hidden_word.

//To select a random word, just pick a random number between 0 and numwords-1, and copy that element of wordlist into the hidden word part of the structure.

// It sets the number of wrong guesses to zero, and initialises the guesses array to be empty (all zeroes).

    g->wrong_guesses = 0 ;

    // DONE

}

The exist code

/* Hangman game!

Author: 1305ENG students
Date: 13/7/2020

A simple hangman game
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <math.h>
// include all OUR function declarations and constants
#include "hangman.h"

// The main function!
int main( int argc, char **argv )
{
char wordfile[256], option, temp[256] ;
char wordlist[MAX_WORDS][MAX_WORD_LENGTH] ;
int num_words, result ;
Game g ;

// seed the rand() function first
srand ( time(NULL));

// check to see if command line argument was given, if so use it as the filename for the words
if ( argc > 1 ){
strcpy ( wordfile, argv[1] ) ;
} else {
strcpy ( wordfile, "wordlist.txt" ) ;
}

// now read word file
num_words = read_words ( wordfile, wordlist ) ;

if ( num_words == 0 ){
printf ( "No words were read from file, exiting\n") ;
exit ( -1 ) ;
}
printf ( "Read %d words from file\n", num_words ) ;

setup_game ( &g, wordlist, num_words ) ;
result = play_game ( &g ) ;
printf ( "Would you like to play again (y/n)? " ) ;
fgets ( temp, 256, stdin ) ; // read the rest of the line to get rid of it from stdin
while ( option == 'y' || option == 'Y' ) ;
return 0 ;
}

// Functions used in the program here!

// WEEK 1 FUNCTIONS
// Replace the call to the library function with your own code

// draw_man()
// Draws the hangman picture for the specified wrong number of moves.
// There is no need to exactly copy the example program, but it should progress from almost nothing
// at zero wrong moves to the man being "hanged" at MAX_WRONG_GUESSES
int draw_man ( int misses ){
return draw_man_lib(int misses);

}

// display_guesses
// Displays a representation of the guessed letters from the guesses array.
// Each letter is displayed in all caps, separated by a space. If the array is '1', that letter is display,
// otherwise if it is '0' it is not. For example if elements 0, 9, and 19 are '1' and the others are 0, then
// "A J T" would be displayed. No newline should be displayed after the list of letters.
int display_guesses( unsigned char guesses[])
{
printf("Guesses so far:");
for(int i=0;i<26;i++)
{
if(guesses[i]==1)//checking the array of guesses if the its there or not
{
printf("%c",i+65);
}
printf("\t");
}
return 0;
}

// read_guess()
// Reads a guess from the user. Uses the guesses array to make sure that the player has not
// already guessed that letter. If an invalid character is entered or they have already guessed
// the letter, they are asked to continue guessing until they enter a valid input.
// Returns the character that was read.
// Note that it is usually better to read an entire line of text rather than a single character, and taking the first
// character of the line as the input. This way, the entire line is removed from the input buffer and won't interfere
// with future input calls.
char read_guess(unsigned char guesses[])
{
return read_guess_lib(guesses);
}
//Week 2 Functions
// add_guess()
// Adds the given guess to the guesses array, making the relevant entry 1. For exmpale, if guess is 'a' or 'A',
// element 0 of the guesses array is set to 1. If 'z' or 'Z' is input, then element 25 is set to 1. Your function
// should check that the character is a valid letter and return -1 if it is not.
// Returns 0 if successful, or -1 if an invalid character is entered.
int add_guess(char guess, unsigned char guesses[26])
{
if ((guess >= 'a' && guess <= 'z') || (guess >= 'A' && guess <= 'Z'))
{
if (guess >= 'a' && guess <= 'z')
{
guesses[guess - 'a'] = 1;
}
else
{
guesses[guess - 'A'] = 1;
}
return 0;
}
return -1;
}
// check_guess()
// Checks if the given character 'guess' is contained within the string 'word'.
// Returns 1 if it is, 0 otherwise
int check_guess ( char word[], char guess )
{
int i;
while(word[i] != '\0')
{
if(guess == word[i])
return 1;
}
return 0;
}
// hidden_word()
// Creates the word that is displayed to the user, with all the correctly guessed letters
// shown, and the rest displayed as underscores. Any non-letters (punctuation, etc) are displayed.
// The function takes two strings as inputs. word[] is the word that the player is trying to guess,
// and display_word[] is the output string to be displayed to the player. The guesses array is a binary
// array of size 26 indicating whether each letter (a-z) has been guessed yet or not.
// Returns 0 if successful, -1 otherwise.
int hidden_word ( char display_word[], char word[], unsigned char guesses[])
{

return hidden_word_lib (display_word, word, guesses);
}
// WEEK 3 FUNCTIONS

// read_words()
// takes a filename as input as well as the wordlist to populate
// Reads from the give file and stores each word (line of text) into a new row of the array.
// A maximum of MAX_WORDS is read, and the wordlist array should be this big (at least).
// Each word read from the file should be a maximum of MAX_wORD_LENGTH characters long.
// Returns the total number of words read. If the file cannot be opened, 0 is returned.
int read_words ( char input[], char wordlist[][MAX_WORD_LENGTH])
{
int count= 0;
FILE*fp = fopen(input, "r");
if(fp == NULL)
return 0;

char buf[MAX_WORD_LENGTH];
while (fscanf(fp, "%s", buf) != EOF && count < MAX_WORDS)
{
strcpy(wordlist[count], buf);
count++;
}
fclose(fp);
return count;
}
// display_game()
// Displays the entire game to the screen. This includes the picture of the hangman, the hidden word,
// and the guesses so far.
int display_game ( Game *g )
{
return display_game_lib (g);
}

// WEEK 4-5 FUNCTIONS

// check_win()
// Checks to see whether all letters in the word have been guessed already.
// The hidden word and guesses inside the Game structure should be used to check this
// Returns 1 if so, 0 otherwise
int check_win ( Game *g ){

return check_win_lib ( g ) ;
}

// setup_game()
// Initialises the given game structure by chooseing a random word from the supplied wordlist.
// The number of words in the wordlist is also passed to the function.
// As well as doing this, the number of incorrect guesses is set to 0, and the guesses array is
// initialised to be all zeros.
int setup_game ( Game *g, char wordlist[][MAX_WORD_LENGTH], int numwords ){

return setup_game_lib ( g, wordlist, numwords ) ;

}

// play_game()
// Runs one complete game of hangman with the supplied Game structure.
// The usual hangman rules are followed - the player guesses letters one at a time until either
// the entire word is guessed or the maximum number of incorrect guesses MAX_WRONG_GUESSES is
// reached. If the player wins, 1 is returned, otherwise 0.
int play_game ( Game *g ){

return play_game_lib ( g );
}

is that an email?

Answer 1

Function body

int setup_game ( Game *g, char wordlist[][MAX_WORD_LENGTH], int numwords )

{
int i;  
int rand_index = rand() % (numwords - 1);//Generates a random index between 0 and numwords-1
  
g->hidden_word = wordlist[rand_index];//Puts the word at the random index into the structure   

  
   for (i = 0; i < MAX_WRONG_GUESSES; i++)
   {
       g->guesses[i] = 0;//Initialising the guesses array to be empty
   }

g->wrong_guesses = 0 ;//It sets the number of wrong guesses to zero

  
}

To run the program I need the hangman.h file but you haven't given it